154 files changed, 11753 insertions, 2771 deletions

diff --git a/Documentation/usb/callbacks.txt b/Documentation/usb/callbacks.txt
index bfb36b34b79e..9e85846bdb98 100644
--- a/Documentation/usb/callbacks.txt
+++ b/Documentation/usb/callbacks.txt
@@ -95,9 +95,11 @@ pre_reset
 
 int (*pre_reset)(struct usb_interface *intf);
 
-Another driver or user space is triggering a reset on the device which
-contains the interface passed as an argument. Cease IO and save any
-device state you need to restore.
+A driver or user space is triggering a reset on the device which
+contains the interface passed as an argument. Cease IO, wait for all
+outstanding URBs to complete, and save any device state you need to
+restore.  No more URBs may be submitted until the post_reset method
+is called.
 
 If you need to allocate memory here, use GFP_NOIO or GFP_ATOMIC, if you
 are in atomic context.
diff --git a/Documentation/usb/linux-cdc-acm.inf b/Documentation/usb/linux-cdc-acm.inf
index 612e7220fb29..37a02ce54841 100644
--- a/Documentation/usb/linux-cdc-acm.inf
+++ b/Documentation/usb/linux-cdc-acm.inf
@@ -90,10 +90,10 @@ ServiceBinary=%12%\USBSER.sys
 [SourceDisksFiles]
 [SourceDisksNames]
 [DeviceList]
-%DESCRIPTION%=DriverInstall, USB\VID_0525&PID_A4A7, USB\VID_0525&PID_A4AB&MI_02
+%DESCRIPTION%=DriverInstall, USB\VID_0525&PID_A4A7, USB\VID_1D6B&PID_0104&MI_02
 
 [DeviceList.NTamd64]
-%DESCRIPTION%=DriverInstall, USB\VID_0525&PID_A4A7, USB\VID_0525&PID_A4AB&MI_02
+%DESCRIPTION%=DriverInstall, USB\VID_0525&PID_A4A7, USB\VID_1D6B&PID_0104&MI_02
 
 
 ;------------------------------------------------------------------------------
diff --git a/Documentation/usb/linux.inf b/Documentation/usb/linux.inf
index 4dee95851224..4ffa715b0ae8 100644
--- a/Documentation/usb/linux.inf
+++ b/Documentation/usb/linux.inf
@@ -18,15 +18,15 @@ DriverVer           = 06/21/2006,6.0.6000.16384
 
 ; Decoration for x86 architecture
 [LinuxDevices.NTx86]
-%LinuxDevice%       = RNDIS.NT.5.1, USB\VID_0525&PID_a4a2, USB\VID_0525&PID_a4ab&MI_00
+%LinuxDevice%       = RNDIS.NT.5.1, USB\VID_0525&PID_a4a2, USB\VID_1d6b&PID_0104&MI_00
 
 ; Decoration for x64 architecture
 [LinuxDevices.NTamd64]
-%LinuxDevice%       = RNDIS.NT.5.1, USB\VID_0525&PID_a4a2, USB\VID_0525&PID_a4ab&MI_00
+%LinuxDevice%       = RNDIS.NT.5.1, USB\VID_0525&PID_a4a2, USB\VID_1d6b&PID_0104&MI_00
 
 ; Decoration for ia64 architecture
 [LinuxDevices.NTia64]
-%LinuxDevice%       = RNDIS.NT.5.1, USB\VID_0525&PID_a4a2, USB\VID_0525&PID_a4ab&MI_00
+%LinuxDevice%       = RNDIS.NT.5.1, USB\VID_0525&PID_a4a2, USB\VID_1d6b&PID_0104&MI_00
 
 ;@@@ This is the common setting for setup
 [ControlFlags]
diff --git a/arch/arm/mach-exynos4/Kconfig b/arch/arm/mach-exynos4/Kconfig
index e849f67be47d..805196207ce8 100644
--- a/arch/arm/mach-exynos4/Kconfig
+++ b/arch/arm/mach-exynos4/Kconfig
@@ -170,6 +170,7 @@ config MACH_NURI
         select S3C_DEV_HSMMC3
         select S3C_DEV_I2C1
         select S3C_DEV_I2C5
+        select S5P_DEV_USB_EHCI
         select EXYNOS4_SETUP_I2C1
         select EXYNOS4_SETUP_I2C5
         select EXYNOS4_SETUP_SDHCI
diff --git a/arch/arm/mach-exynos4/Makefile b/arch/arm/mach-exynos4/Makefile
index 9be104f63c0b..777897551e42 100644
--- a/arch/arm/mach-exynos4/Makefile
+++ b/arch/arm/mach-exynos4/Makefile
@@ -54,3 +54,5 @@ obj-$(CONFIG_EXYNOS4_SETUP_I2C7)	+= setup-i2c7.o
 obj-$(CONFIG_EXYNOS4_SETUP_KEYPAD)      += setup-keypad.o
 obj-$(CONFIG_EXYNOS4_SETUP_SDHCI)       += setup-sdhci.o
 obj-$(CONFIG_EXYNOS4_SETUP_SDHCI_GPIO)  += setup-sdhci-gpio.o
+
+obj-$(CONFIG_USB_SUPPORT)               += usb-phy.o
diff --git a/arch/arm/mach-exynos4/cpu.c b/arch/arm/mach-exynos4/cpu.c
index 793011391943..08813a6f66b1 100644
--- a/arch/arm/mach-exynos4/cpu.c
+++ b/arch/arm/mach-exynos4/cpu.c
@@ -97,7 +97,12 @@ static struct map_desc exynos4_iodesc[] __initdata = {
                 .pfn            = __phys_to_pfn(EXYNOS4_PA_SROMC),
                 .length         = SZ_4K,
                 .type           = MT_DEVICE,
-        },
+        }, {
+                .virtual        = (unsigned long)S5P_VA_USB_HSPHY,
+                .pfn            = __phys_to_pfn(EXYNOS4_PA_HSPHY),
+                .length         = SZ_4K,
+                .type           = MT_DEVICE,
+        }
 };
 
 static void exynos4_idle(void)
diff --git a/arch/arm/mach-exynos4/include/mach/map.h b/arch/arm/mach-exynos4/include/mach/map.h
index 6330b73b9ea7..0009e77a05fc 100644
--- a/arch/arm/mach-exynos4/include/mach/map.h
+++ b/arch/arm/mach-exynos4/include/mach/map.h
@@ -101,6 +101,9 @@
 
 #define EXYNOS4_PA_SROMC                0x12570000
 
+#define EXYNOS4_PA_EHCI                 0x12580000
+#define EXYNOS4_PA_HSPHY                0x125B0000
+
 #define EXYNOS4_PA_UART                 0x13800000
 
 #define EXYNOS4_PA_IIC(x)               (0x13860000 + ((x) * 0x10000))
@@ -143,6 +146,7 @@
 #define S5P_PA_SROMC                    EXYNOS4_PA_SROMC
 #define S5P_PA_SYSCON                   EXYNOS4_PA_SYSCON
 #define S5P_PA_TIMER                    EXYNOS4_PA_TIMER
+#define S5P_PA_EHCI                     EXYNOS4_PA_EHCI
 
 #define SAMSUNG_PA_KEYPAD               EXYNOS4_PA_KEYPAD
 
diff --git a/arch/arm/mach-exynos4/include/mach/regs-pmu.h b/arch/arm/mach-exynos4/include/mach/regs-pmu.h
index 62b0014d05e0..a9643371f8e7 100644
--- a/arch/arm/mach-exynos4/include/mach/regs-pmu.h
+++ b/arch/arm/mach-exynos4/include/mach/regs-pmu.h
@@ -33,6 +33,9 @@
 #define S5P_EINT_WAKEUP_MASK                    S5P_PMUREG(0x0604)
 #define S5P_WAKEUP_MASK                         S5P_PMUREG(0x0608)
 
+#define S5P_USBHOST_PHY_CONTROL                 S5P_PMUREG(0x0708)
+#define S5P_USBHOST_PHY_ENABLE                  (1 << 0)
+
 #define S5P_MIPI_DPHY_CONTROL(n)                S5P_PMUREG(0x0710 + (n) * 4)
 #define S5P_MIPI_DPHY_ENABLE                    (1 << 0)
 #define S5P_MIPI_DPHY_SRESETN                   (1 << 1)
diff --git a/arch/arm/mach-exynos4/include/mach/regs-usb-phy.h b/arch/arm/mach-exynos4/include/mach/regs-usb-phy.h
new file mode 100644
index 000000000000..703118d5173c
--- /dev/null
+++ b/arch/arm/mach-exynos4/include/mach/regs-usb-phy.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2011 Samsung Electronics Co.Ltd
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#ifndef __PLAT_S5P_REGS_USB_PHY_H
+#define __PLAT_S5P_REGS_USB_PHY_H
+
+#define EXYNOS4_HSOTG_PHYREG(x)         ((x) + S5P_VA_USB_HSPHY)
+
+#define EXYNOS4_PHYPWR                  EXYNOS4_HSOTG_PHYREG(0x00)
+#define PHY1_HSIC_NORMAL_MASK           (0xf << 9)
+#define PHY1_HSIC1_SLEEP                (1 << 12)
+#define PHY1_HSIC1_FORCE_SUSPEND        (1 << 11)
+#define PHY1_HSIC0_SLEEP                (1 << 10)
+#define PHY1_HSIC0_FORCE_SUSPEND        (1 << 9)
+
+#define PHY1_STD_NORMAL_MASK            (0x7 << 6)
+#define PHY1_STD_SLEEP                  (1 << 8)
+#define PHY1_STD_ANALOG_POWERDOWN       (1 << 7)
+#define PHY1_STD_FORCE_SUSPEND          (1 << 6)
+
+#define PHY0_NORMAL_MASK                (0x39 << 0)
+#define PHY0_SLEEP                      (1 << 5)
+#define PHY0_OTG_DISABLE                (1 << 4)
+#define PHY0_ANALOG_POWERDOWN           (1 << 3)
+#define PHY0_FORCE_SUSPEND              (1 << 0)
+
+#define EXYNOS4_PHYCLK                  EXYNOS4_HSOTG_PHYREG(0x04)
+#define PHY1_COMMON_ON_N                (1 << 7)
+#define PHY0_COMMON_ON_N                (1 << 4)
+#define PHY0_ID_PULLUP                  (1 << 2)
+#define CLKSEL_MASK                     (0x3 << 0)
+#define CLKSEL_SHIFT                    (0)
+#define CLKSEL_48M                      (0x0 << 0)
+#define CLKSEL_12M                      (0x2 << 0)
+#define CLKSEL_24M                      (0x3 << 0)
+
+#define EXYNOS4_RSTCON                  EXYNOS4_HSOTG_PHYREG(0x08)
+#define HOST_LINK_PORT_SWRST_MASK       (0xf << 6)
+#define HOST_LINK_PORT2_SWRST           (1 << 9)
+#define HOST_LINK_PORT1_SWRST           (1 << 8)
+#define HOST_LINK_PORT0_SWRST           (1 << 7)
+#define HOST_LINK_ALL_SWRST             (1 << 6)
+
+#define PHY1_SWRST_MASK                 (0x7 << 3)
+#define PHY1_HSIC_SWRST                 (1 << 5)
+#define PHY1_STD_SWRST                  (1 << 4)
+#define PHY1_ALL_SWRST                  (1 << 3)
+
+#define PHY0_SWRST_MASK                 (0x7 << 0)
+#define PHY0_PHYLINK_SWRST              (1 << 2)
+#define PHY0_HLINK_SWRST                (1 << 1)
+#define PHY0_SWRST                      (1 << 0)
+
+#define EXYNOS4_PHY1CON                 EXYNOS4_HSOTG_PHYREG(0x34)
+#define FPENABLEN                       (1 << 0)
+
+#endif /* __PLAT_S5P_REGS_USB_PHY_H */
diff --git a/arch/arm/mach-exynos4/mach-nuri.c b/arch/arm/mach-exynos4/mach-nuri.c
index b79ad010d194..bb5d12f43af8 100644
--- a/arch/arm/mach-exynos4/mach-nuri.c
+++ b/arch/arm/mach-exynos4/mach-nuri.c
@@ -30,6 +30,8 @@
 #include <plat/cpu.h>
 #include <plat/devs.h>
 #include <plat/sdhci.h>
+#include <plat/ehci.h>
+#include <plat/clock.h>
 
 #include <mach/map.h>
 
@@ -262,6 +264,16 @@ static struct i2c_board_info i2c5_devs[] __initdata = {
         /* max8997, To be updated */
 };
 
+/* USB EHCI */
+static struct s5p_ehci_platdata nuri_ehci_pdata;
+
+static void __init nuri_ehci_init(void)
+{
+        struct s5p_ehci_platdata *pdata = &nuri_ehci_pdata;
+
+        s5p_ehci_set_platdata(pdata);
+}
+
 static struct platform_device *nuri_devices[] __initdata = {
         /* Samsung Platform Devices */
         &emmc_fixed_voltage,
@@ -270,6 +282,7 @@ static struct platform_device *nuri_devices[] __initdata = {
         &s3c_device_hsmmc3,
         &s3c_device_wdt,
         &s3c_device_timer[0],
+        &s5p_device_ehci,
 
         /* NURI Devices */
         &nuri_gpio_keys,
@@ -291,6 +304,9 @@ static void __init nuri_machine_init(void)
         i2c_register_board_info(1, i2c1_devs, ARRAY_SIZE(i2c1_devs));
         i2c_register_board_info(5, i2c5_devs, ARRAY_SIZE(i2c5_devs));
 
+        nuri_ehci_init();
+        clk_xusbxti.rate = 24000000;
+
         /* Last */
         platform_add_devices(nuri_devices, ARRAY_SIZE(nuri_devices));
 }
diff --git a/arch/arm/mach-exynos4/usb-phy.c b/arch/arm/mach-exynos4/usb-phy.c
new file mode 100644
index 000000000000..0883c1b824b9
--- /dev/null
+++ b/arch/arm/mach-exynos4/usb-phy.c
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2011 Samsung Electronics Co.Ltd
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <mach/regs-pmu.h>
+#include <mach/regs-usb-phy.h>
+#include <plat/cpu.h>
+#include <plat/usb-phy.h>
+
+static int exynos4_usb_phy1_init(struct platform_device *pdev)
+{
+        struct clk *otg_clk;
+        struct clk *xusbxti_clk;
+        u32 phyclk;
+        u32 rstcon;
+        int err;
+
+        otg_clk = clk_get(&pdev->dev, "otg");
+        if (IS_ERR(otg_clk)) {
+                dev_err(&pdev->dev, "Failed to get otg clock\n");
+                return PTR_ERR(otg_clk);
+        }
+
+        err = clk_enable(otg_clk);
+        if (err) {
+                clk_put(otg_clk);
+                return err;
+        }
+
+        writel(readl(S5P_USBHOST_PHY_CONTROL) | S5P_USBHOST_PHY_ENABLE,
+                        S5P_USBHOST_PHY_CONTROL);
+
+        /* set clock frequency for PLL */
+        phyclk = readl(EXYNOS4_PHYCLK) & ~CLKSEL_MASK;
+
+        xusbxti_clk = clk_get(&pdev->dev, "xusbxti");
+        if (xusbxti_clk && !IS_ERR(xusbxti_clk)) {
+                switch (clk_get_rate(xusbxti_clk)) {
+                case 12 * MHZ:
+                        phyclk |= CLKSEL_12M;
+                        break;
+                case 24 * MHZ:
+                        phyclk |= CLKSEL_24M;
+                        break;
+                default:
+                case 48 * MHZ:
+                        /* default reference clock */
+                        break;
+                }
+                clk_put(xusbxti_clk);
+        }
+
+        writel(phyclk, EXYNOS4_PHYCLK);
+
+        /* floating prevention logic: disable */
+        writel((readl(EXYNOS4_PHY1CON) | FPENABLEN), EXYNOS4_PHY1CON);
+
+        /* set to normal HSIC 0 and 1 of PHY1 */
+        writel((readl(EXYNOS4_PHYPWR) & ~PHY1_HSIC_NORMAL_MASK),
+                        EXYNOS4_PHYPWR);
+
+        /* set to normal standard USB of PHY1 */
+        writel((readl(EXYNOS4_PHYPWR) & ~PHY1_STD_NORMAL_MASK), EXYNOS4_PHYPWR);
+
+        /* reset all ports of both PHY and Link */
+        rstcon = readl(EXYNOS4_RSTCON) | HOST_LINK_PORT_SWRST_MASK |
+                PHY1_SWRST_MASK;
+        writel(rstcon, EXYNOS4_RSTCON);
+        udelay(10);
+
+        rstcon &= ~(HOST_LINK_PORT_SWRST_MASK | PHY1_SWRST_MASK);
+        writel(rstcon, EXYNOS4_RSTCON);
+        udelay(50);
+
+        clk_disable(otg_clk);
+        clk_put(otg_clk);
+
+        return 0;
+}
+
+static int exynos4_usb_phy1_exit(struct platform_device *pdev)
+{
+        struct clk *otg_clk;
+        int err;
+
+        otg_clk = clk_get(&pdev->dev, "otg");
+        if (IS_ERR(otg_clk)) {
+                dev_err(&pdev->dev, "Failed to get otg clock\n");
+                return PTR_ERR(otg_clk);
+        }
+
+        err = clk_enable(otg_clk);
+        if (err) {
+                clk_put(otg_clk);
+                return err;
+        }
+
+        writel((readl(EXYNOS4_PHYPWR) | PHY1_STD_ANALOG_POWERDOWN),
+                        EXYNOS4_PHYPWR);
+
+        writel(readl(S5P_USBHOST_PHY_CONTROL) & ~S5P_USBHOST_PHY_ENABLE,
+                        S5P_USBHOST_PHY_CONTROL);
+
+        clk_disable(otg_clk);
+        clk_put(otg_clk);
+
+        return 0;
+}
+
+int s5p_usb_phy_init(struct platform_device *pdev, int type)
+{
+        if (type == S5P_USB_PHY_HOST)
+                return exynos4_usb_phy1_init(pdev);
+
+        return -EINVAL;
+}
+
+int s5p_usb_phy_exit(struct platform_device *pdev, int type)
+{
+        if (type == S5P_USB_PHY_HOST)
+                return exynos4_usb_phy1_exit(pdev);
+
+        return -EINVAL;
+}
diff --git a/arch/arm/plat-s5p/Kconfig b/arch/arm/plat-s5p/Kconfig
index 849229716586..6751bcf7b888 100644
--- a/arch/arm/plat-s5p/Kconfig
+++ b/arch/arm/plat-s5p/Kconfig
@@ -85,6 +85,11 @@ config S5P_DEV_CSIS1
         help
           Compile in platform device definitions for MIPI-CSIS channel 1
 
+config S5P_DEV_USB_EHCI
+        bool
+        help
+          Compile in platform device definition for USB EHCI
+
 config S5P_SETUP_MIPIPHY
         bool
         help
diff --git a/arch/arm/plat-s5p/Makefile b/arch/arm/plat-s5p/Makefile
index 42afff7f60be..e234cc4d49a0 100644
--- a/arch/arm/plat-s5p/Makefile
+++ b/arch/arm/plat-s5p/Makefile
@@ -33,4 +33,5 @@ obj-$(CONFIG_S5P_DEV_FIMC3)	+= dev-fimc3.o
 obj-$(CONFIG_S5P_DEV_ONENAND)   += dev-onenand.o
 obj-$(CONFIG_S5P_DEV_CSIS0)     += dev-csis0.o
 obj-$(CONFIG_S5P_DEV_CSIS1)     += dev-csis1.o
+obj-$(CONFIG_S5P_DEV_USB_EHCI)  += dev-ehci.o
 obj-$(CONFIG_S5P_SETUP_MIPIPHY) += setup-mipiphy.o
diff --git a/arch/arm/plat-s5p/dev-ehci.c b/arch/arm/plat-s5p/dev-ehci.c
new file mode 100644
index 000000000000..94080fff9e9b
--- /dev/null
+++ b/arch/arm/plat-s5p/dev-ehci.c
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2011 Samsung Electronics Co.Ltd
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/platform_device.h>
+#include <mach/irqs.h>
+#include <mach/map.h>
+#include <plat/devs.h>
+#include <plat/ehci.h>
+#include <plat/usb-phy.h>
+
+/* USB EHCI Host Controller registration */
+static struct resource s5p_ehci_resource[] = {
+        [0] = {
+                .start  = S5P_PA_EHCI,
+                .end    = S5P_PA_EHCI + SZ_256 - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = IRQ_USB_HOST,
+                .end    = IRQ_USB_HOST,
+                .flags  = IORESOURCE_IRQ,
+        }
+};
+
+static u64 s5p_device_ehci_dmamask = 0xffffffffUL;
+
+struct platform_device s5p_device_ehci = {
+        .name           = "s5p-ehci",
+        .id             = -1,
+        .num_resources  = ARRAY_SIZE(s5p_ehci_resource),
+        .resource       = s5p_ehci_resource,
+        .dev            = {
+                .dma_mask = &s5p_device_ehci_dmamask,
+                .coherent_dma_mask = 0xffffffffUL
+        }
+};
+
+void __init s5p_ehci_set_platdata(struct s5p_ehci_platdata *pd)
+{
+        struct s5p_ehci_platdata *npd;
+
+        npd = s3c_set_platdata(pd, sizeof(struct s5p_ehci_platdata),
+                        &s5p_device_ehci);
+
+        if (!npd->phy_init)
+                npd->phy_init = s5p_usb_phy_init;
+        if (!npd->phy_exit)
+                npd->phy_exit = s5p_usb_phy_exit;
+}
diff --git a/arch/arm/plat-s5p/include/plat/ehci.h b/arch/arm/plat-s5p/include/plat/ehci.h
new file mode 100644
index 000000000000..6ae6810c7569
--- /dev/null
+++ b/arch/arm/plat-s5p/include/plat/ehci.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2011 Samsung Electronics Co.Ltd
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#ifndef __PLAT_S5P_EHCI_H
+#define __PLAT_S5P_EHCI_H
+
+struct s5p_ehci_platdata {
+        int (*phy_init)(struct platform_device *pdev, int type);
+        int (*phy_exit)(struct platform_device *pdev, int type);
+};
+
+extern void s5p_ehci_set_platdata(struct s5p_ehci_platdata *pd);
+
+#endif /* __PLAT_S5P_EHCI_H */
diff --git a/arch/arm/plat-s5p/include/plat/map-s5p.h b/arch/arm/plat-s5p/include/plat/map-s5p.h
index d973d39666a3..a6c3d327ce72 100644
--- a/arch/arm/plat-s5p/include/plat/map-s5p.h
+++ b/arch/arm/plat-s5p/include/plat/map-s5p.h
@@ -39,7 +39,7 @@
 #define S5P_VA_TWD              S5P_VA_COREPERI(0x600)
 #define S5P_VA_GIC_DIST         S5P_VA_COREPERI(0x1000)
 
-#define S3C_VA_USB_HSPHY        S3C_ADDR(0x02900000)
+#define S5P_VA_USB_HSPHY        S3C_ADDR(0x02900000)
 
 #define VA_VIC(x)               (S3C_VA_IRQ + ((x) * 0x10000))
 #define VA_VIC0                 VA_VIC(0)
diff --git a/arch/arm/plat-s5p/include/plat/usb-phy.h b/arch/arm/plat-s5p/include/plat/usb-phy.h
new file mode 100644
index 000000000000..6dd6bcfca3ce
--- /dev/null
+++ b/arch/arm/plat-s5p/include/plat/usb-phy.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2011 Samsung Electronics Co.Ltd
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#ifndef __PLAT_S5P_USB_PHY_H
+#define __PLAT_S5P_USB_PHY_H
+
+enum s5p_usb_phy_type {
+        S5P_USB_PHY_DEVICE,
+        S5P_USB_PHY_HOST,
+};
+
+extern int s5p_usb_phy_init(struct platform_device *pdev, int type);
+extern int s5p_usb_phy_exit(struct platform_device *pdev, int type);
+
+#endif /* __PLAT_S5P_REGS_USB_PHY_H */
diff --git a/arch/arm/plat-samsung/include/plat/devs.h b/arch/arm/plat-samsung/include/plat/devs.h
index f0da6b70fba4..3f38debbb108 100644
--- a/arch/arm/plat-samsung/include/plat/devs.h
+++ b/arch/arm/plat-samsung/include/plat/devs.h
@@ -142,6 +142,8 @@ extern struct platform_device s5p_device_fimc3;
 extern struct platform_device s5p_device_mipi_csis0;
 extern struct platform_device s5p_device_mipi_csis1;
 
+extern struct platform_device s5p_device_ehci;
+
 extern struct platform_device exynos4_device_sysmmu;
 
 /* s3c2440 specific devices */
diff --git a/arch/mips/ath79/Kconfig b/arch/mips/ath79/Kconfig
index b05828260f7f..47707410582c 100644
--- a/arch/mips/ath79/Kconfig
+++ b/arch/mips/ath79/Kconfig
@@ -26,12 +26,17 @@ config ATH79_MACH_PB44
 endmenu
 
 config SOC_AR71XX
+        select USB_ARCH_HAS_EHCI
+        select USB_ARCH_HAS_OHCI
         def_bool n
 
 config SOC_AR724X
+        select USB_ARCH_HAS_EHCI
+        select USB_ARCH_HAS_OHCI
         def_bool n
 
 config SOC_AR913X
+        select USB_ARCH_HAS_EHCI
         def_bool n
 
 config ATH79_DEV_AR913X_WMAC
diff --git a/drivers/Makefile b/drivers/Makefile
index 3f135b6fb014..0cf73a90fca8 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -64,11 +64,10 @@ obj-$(CONFIG_ATA_OVER_ETH)	+= block/aoe/
 obj-$(CONFIG_PARIDE)            += block/paride/
 obj-$(CONFIG_TC)                += tc/
 obj-$(CONFIG_UWB)               += uwb/
-obj-$(CONFIG_USB_OTG_UTILS)     += usb/otg/
+obj-$(CONFIG_USB_OTG_UTILS)     += usb/
 obj-$(CONFIG_USB)               += usb/
-obj-$(CONFIG_USB_MUSB_HDRC)     += usb/musb/
 obj-$(CONFIG_PCI)               += usb/
-obj-$(CONFIG_USB_GADGET)        += usb/gadget/
+obj-$(CONFIG_USB_GADGET)        += usb/
 obj-$(CONFIG_SERIO)             += input/serio/
 obj-$(CONFIG_GAMEPORT)          += input/gameport/
 obj-$(CONFIG_INPUT)             += input/
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 408c4bea4d8d..86a64fa6e26d 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1760,19 +1760,37 @@ static const struct hid_device_id hid_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_KYE, 0x0058) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIC) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOTOR) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 00a94b535d28..a8a05835fb49 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -367,19 +367,38 @@
 
 #define USB_VENDOR_ID_LD                0x0f11
 #define USB_DEVICE_ID_LD_CASSY          0x1000
+#define USB_DEVICE_ID_LD_CASSY2         0x1001
 #define USB_DEVICE_ID_LD_POCKETCASSY    0x1010
+#define USB_DEVICE_ID_LD_POCKETCASSY2   0x1011
 #define USB_DEVICE_ID_LD_MOBILECASSY    0x1020
+#define USB_DEVICE_ID_LD_MOBILECASSY2   0x1021
+#define USB_DEVICE_ID_LD_MICROCASSYVOLTAGE      0x1031
+#define USB_DEVICE_ID_LD_MICROCASSYCURRENT      0x1032
+#define USB_DEVICE_ID_LD_MICROCASSYTIME         0x1033
+#define USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE  0x1035
+#define USB_DEVICE_ID_LD_MICROCASSYPH           0x1038
 #define USB_DEVICE_ID_LD_JWM            0x1080
 #define USB_DEVICE_ID_LD_DMMP           0x1081
 #define USB_DEVICE_ID_LD_UMIP           0x1090
-#define USB_DEVICE_ID_LD_XRAY1          0x1100
+#define USB_DEVICE_ID_LD_UMIC           0x10A0
+#define USB_DEVICE_ID_LD_UMIB           0x10B0
+#define USB_DEVICE_ID_LD_XRAY           0x1100
 #define USB_DEVICE_ID_LD_XRAY2          0x1101
+#define USB_DEVICE_ID_LD_XRAYCT         0x1110
 #define USB_DEVICE_ID_LD_VIDEOCOM       0x1200
+#define USB_DEVICE_ID_LD_MOTOR          0x1210
 #define USB_DEVICE_ID_LD_COM3LAB        0x2000
 #define USB_DEVICE_ID_LD_TELEPORT       0x2010
 #define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020
 #define USB_DEVICE_ID_LD_POWERCONTROL   0x2030
 #define USB_DEVICE_ID_LD_MACHINETEST    0x2040
+#define USB_DEVICE_ID_LD_MOSTANALYSER   0x2050
+#define USB_DEVICE_ID_LD_MOSTANALYSER2  0x2051
+#define USB_DEVICE_ID_LD_ABSESP         0x2060
+#define USB_DEVICE_ID_LD_AUTODATABUS    0x2070
+#define USB_DEVICE_ID_LD_MCT            0x2080
+#define USB_DEVICE_ID_LD_HYBRID         0x2090
+#define USB_DEVICE_ID_LD_HEATCONTROL    0x20A0
 
 #define USB_VENDOR_ID_LOGITECH          0x046d
 #define USB_DEVICE_ID_LOGITECH_RECEIVER 0xc101
diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 006489d82dc3..48f1781352f1 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -65,8 +65,10 @@ config USB_ARCH_HAS_EHCI
         default y if ARCH_CNS3XXX
         default y if ARCH_VT8500
         default y if PLAT_SPEAR
+        default y if PLAT_S5P
         default y if ARCH_MSM
         default y if MICROBLAZE
+        default y if SPARC_LEON
         default PCI
 
 # ARM SA1111 chips have a non-PCI based "OHCI-compatible" USB host interface.
@@ -116,6 +118,8 @@ source "drivers/usb/host/Kconfig"
 
 source "drivers/usb/musb/Kconfig"
 
+source "drivers/usb/renesas_usbhs/Kconfig"
+
 source "drivers/usb/class/Kconfig"
 
 source "drivers/usb/storage/Kconfig"
diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index 239f050efa35..30ddf8dc4f72 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_USB_R8A66597_HCD)	+= host/
 obj-$(CONFIG_USB_HWA_HCD)       += host/
 obj-$(CONFIG_USB_ISP1760_HCD)   += host/
 obj-$(CONFIG_USB_IMX21_HCD)     += host/
+obj-$(CONFIG_USB_FSL_MPH_DR_OF) += host/
 
 obj-$(CONFIG_USB_C67X00_HCD)    += c67x00/
 
@@ -45,3 +46,8 @@ obj-$(CONFIG_EARLY_PRINTK_DBGP)	+= early/
 
 obj-$(CONFIG_USB_ATM)           += atm/
 obj-$(CONFIG_USB_SPEEDTOUCH)    += atm/
+
+obj-$(CONFIG_USB_MUSB_HDRC)     += musb/
+obj-$(CONFIG_USB_RENESAS_USBHS) += renesas_usbhs/
+obj-$(CONFIG_USB_OTG_UTILS)     += otg/
+obj-$(CONFIG_USB_GADGET)        += gadget/
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index e057e5381465..58754b508a0f 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -7,35 +7,12 @@
  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
  * Copyright (c) 2004 Oliver Neukum     <oliver@neukum.name>
  * Copyright (c) 2005 David Kubicek     <dave@awk.cz>
+ * Copyright (c) 2011 Johan Hovold      <jhovold@gmail.com>
  *
  * USB Abstract Control Model driver for USB modems and ISDN adapters
  *
  * Sponsored by SuSE
  *
- * ChangeLog:
- *      v0.9  - thorough cleaning, URBification, almost a rewrite
- *      v0.10 - some more cleanups
- *      v0.11 - fixed flow control, read error doesn't stop reads
- *      v0.12 - added TIOCM ioctls, added break handling, made struct acm
- *              kmalloced
- *      v0.13 - added termios, added hangup
- *      v0.14 - sized down struct acm
- *      v0.15 - fixed flow control again - characters could be lost
- *      v0.16 - added code for modems with swapped data and control interfaces
- *      v0.17 - added new style probing
- *      v0.18 - fixed new style probing for devices with more configurations
- *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
- *      v0.20 - switched to probing on interface (rather than device) class
- *      v0.21 - revert to probing on device for devices with multiple configs
- *      v0.22 - probe only the control interface. if usbcore doesn't choose the
- *              config we want, sysadmin changes bConfigurationValue in sysfs.
- *      v0.23 - use softirq for rx processing, as needed by tty layer
- *      v0.24 - change probe method to evaluate CDC union descriptor
- *      v0.25 - downstream tasks paralelized to maximize throughput
- *      v0.26 - multiple write urbs, writesize increased
- */
-
-/*
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
@@ -74,13 +51,7 @@
 #include "cdc-acm.h"
 
 
-#define ACM_CLOSE_TIMEOUT       15      /* seconds to let writes drain */
-
-/*
- * Version Information
- */
-#define DRIVER_VERSION "v0.26"
-#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
+#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
 
 static struct usb_driver acm_driver;
@@ -94,12 +65,6 @@ static DEFINE_MUTEX(open_mutex);
 static const struct tty_port_operations acm_port_ops = {
 };
 
-#ifdef VERBOSE_DEBUG
-#define verbose 1
-#else
-#define verbose 0
-#endif
-
 /*
  * Functions for ACM control messages.
  */
@@ -111,8 +76,9 @@ static int acm_ctrl_msg(struct acm *acm, int request, int value,
                 request, USB_RT_ACM, value,
                 acm->control->altsetting[0].desc.bInterfaceNumber,
                 buf, len, 5000);
-        dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
-                                                request, value, len, retval);
+        dev_dbg(&acm->control->dev,
+                        "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
+                        __func__, request, value, len, retval);
         return retval < 0 ? retval : 0;
 }
 
@@ -192,7 +158,9 @@ static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 
         rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
         if (rc < 0) {
-                dbg("usb_submit_urb(write bulk) failed: %d", rc);
+                dev_err(&acm->data->dev,
+                        "%s - usb_submit_urb(write bulk) failed: %d\n",
+                        __func__, rc);
                 acm_write_done(acm, wb);
         }
         return rc;
@@ -211,7 +179,8 @@ static int acm_write_start(struct acm *acm, int wbn)
                 return -ENODEV;
         }
 
-        dbg("%s susp_count: %d", __func__, acm->susp_count);
+        dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
+                                                        acm->susp_count);
         usb_autopm_get_interface_async(acm->control);
         if (acm->susp_count) {
                 if (!acm->delayed_wb)
@@ -287,10 +256,14 @@ static void acm_ctrl_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__, status);
+                dev_dbg(&acm->control->dev,
+                                "%s - urb shutting down with status: %d\n",
+                                __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__, status);
+                dev_dbg(&acm->control->dev,
+                                "%s - nonzero urb status received: %d\n",
+                                __func__, status);
                 goto exit;
         }
 
@@ -302,8 +275,8 @@ static void acm_ctrl_irq(struct urb *urb)
         data = (unsigned char *)(dr + 1);
         switch (dr->bNotificationType) {
         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
-                dbg("%s network", dr->wValue ?
-                                        "connected to" : "disconnected from");
+                dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
+                                                        __func__, dr->wValue);
                 break;
 
         case USB_CDC_NOTIFY_SERIAL_STATE:
@@ -313,7 +286,8 @@ static void acm_ctrl_irq(struct urb *urb)
                 if (tty) {
                         if (!acm->clocal &&
                                 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
-                                dbg("calling hangup");
+                                dev_dbg(&acm->control->dev,
+                                        "%s - calling hangup\n", __func__);
                                 tty_hangup(tty);
                         }
                         tty_kref_put(tty);
@@ -321,7 +295,10 @@ static void acm_ctrl_irq(struct urb *urb)
 
                 acm->ctrlin = newctrl;
 
-                dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
+                dev_dbg(&acm->control->dev,
+                        "%s - input control lines: dcd%c dsr%c break%c "
+                        "ring%c framing%c parity%c overrun%c\n",
+                        __func__,
                         acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
                         acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
                         acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
@@ -332,7 +309,10 @@ static void acm_ctrl_irq(struct urb *urb)
                         break;
 
         default:
-                dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
+                dev_dbg(&acm->control->dev,
+                        "%s - unknown notification %d received: index %d "
+                        "len %d data0 %d data1 %d\n",
+                        __func__,
                         dr->bNotificationType, dr->wIndex,
                         dr->wLength, data[0], data[1]);
                 break;
@@ -340,166 +320,96 @@ static void acm_ctrl_irq(struct urb *urb)
 exit:
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
-                dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
-                        "result %d", __func__, retval);
+                dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
+                                                        __func__, retval);
 }
 
-/* data interface returns incoming bytes, or we got unthrottled */
-static void acm_read_bulk(struct urb *urb)
+static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
 {
-        struct acm_rb *buf;
-        struct acm_ru *rcv = urb->context;
-        struct acm *acm = rcv->instance;
-        int status = urb->status;
+        int res;
+
+        if (!test_and_clear_bit(index, &acm->read_urbs_free))
+                return 0;
 
-        dbg("Entering acm_read_bulk with status %d", status);
+        dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
 
-        if (!ACM_READY(acm)) {
-                dev_dbg(&acm->data->dev, "Aborting, acm not ready");
-                return;
+        res = usb_submit_urb(acm->read_urbs[index], mem_flags);
+        if (res) {
+                if (res != -EPERM) {
+                        dev_err(&acm->data->dev,
+                                        "%s - usb_submit_urb failed: %d\n",
+                                        __func__, res);
+                }
+                set_bit(index, &acm->read_urbs_free);
+                return res;
         }
-        usb_mark_last_busy(acm->dev);
 
-        if (status)
-                dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
+        return 0;
+}
 
-        buf = rcv->buffer;
-        buf->size = urb->actual_length;
+static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
+{
+        int res;
+        int i;
 
-        if (likely(status == 0)) {
-                spin_lock(&acm->read_lock);
-                acm->processing++;
-                list_add_tail(&rcv->list, &acm->spare_read_urbs);
-                list_add_tail(&buf->list, &acm->filled_read_bufs);
-                spin_unlock(&acm->read_lock);
-        } else {
-                /* we drop the buffer due to an error */
-                spin_lock(&acm->read_lock);
-                list_add_tail(&rcv->list, &acm->spare_read_urbs);
-                list_add(&buf->list, &acm->spare_read_bufs);
-                spin_unlock(&acm->read_lock);
-                /* nevertheless the tasklet must be kicked unconditionally
-                so the queue cannot dry up */
+        for (i = 0; i < acm->rx_buflimit; ++i) {
+                res = acm_submit_read_urb(acm, i, mem_flags);
+                if (res)
+                        return res;
         }
-        if (likely(!acm->susp_count))
-                tasklet_schedule(&acm->urb_task);
+
+        return 0;
 }
 
-static void acm_rx_tasklet(unsigned long _acm)
+static void acm_process_read_urb(struct acm *acm, struct urb *urb)
 {
-        struct acm *acm = (void *)_acm;
-        struct acm_rb *buf;
         struct tty_struct *tty;
-        struct acm_ru *rcv;
-        unsigned long flags;
-        unsigned char throttled;
-
-        dbg("Entering acm_rx_tasklet");
 
-        if (!ACM_READY(acm)) {
-                dbg("acm_rx_tasklet: ACM not ready");
+        if (!urb->actual_length)
                 return;
-        }
-
-        spin_lock_irqsave(&acm->throttle_lock, flags);
-        throttled = acm->throttle;
-        spin_unlock_irqrestore(&acm->throttle_lock, flags);
-        if (throttled) {
-                dbg("acm_rx_tasklet: throttled");
-                return;
-        }
 
         tty = tty_port_tty_get(&acm->port);
+        if (!tty)
+                return;
 
-next_buffer:
-        spin_lock_irqsave(&acm->read_lock, flags);
-        if (list_empty(&acm->filled_read_bufs)) {
-                spin_unlock_irqrestore(&acm->read_lock, flags);
-                goto urbs;
-        }
-        buf = list_entry(acm->filled_read_bufs.next,
-                         struct acm_rb, list);
-        list_del(&buf->list);
-        spin_unlock_irqrestore(&acm->read_lock, flags);
-
-        dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
-
-        if (tty) {
-                spin_lock_irqsave(&acm->throttle_lock, flags);
-                throttled = acm->throttle;
-                spin_unlock_irqrestore(&acm->throttle_lock, flags);
-                if (!throttled) {
-                        tty_insert_flip_string(tty, buf->base, buf->size);
-                        tty_flip_buffer_push(tty);
-                } else {
-                        tty_kref_put(tty);
-                        dbg("Throttling noticed");
-                        spin_lock_irqsave(&acm->read_lock, flags);
-                        list_add(&buf->list, &acm->filled_read_bufs);
-                        spin_unlock_irqrestore(&acm->read_lock, flags);
-                        return;
-                }
-        }
-
-        spin_lock_irqsave(&acm->read_lock, flags);
-        list_add(&buf->list, &acm->spare_read_bufs);
-        spin_unlock_irqrestore(&acm->read_lock, flags);
-        goto next_buffer;
+        tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
+        tty_flip_buffer_push(tty);
 
-urbs:
         tty_kref_put(tty);
+}
 
-        while (!list_empty(&acm->spare_read_bufs)) {
-                spin_lock_irqsave(&acm->read_lock, flags);
-                if (list_empty(&acm->spare_read_urbs)) {
-                        acm->processing = 0;
-                        spin_unlock_irqrestore(&acm->read_lock, flags);
-                        return;
-                }
-                rcv = list_entry(acm->spare_read_urbs.next,
-                                 struct acm_ru, list);
-                list_del(&rcv->list);
-                spin_unlock_irqrestore(&acm->read_lock, flags);
+static void acm_read_bulk_callback(struct urb *urb)
+{
+        struct acm_rb *rb = urb->context;
+        struct acm *acm = rb->instance;
+        unsigned long flags;
 
-                buf = list_entry(acm->spare_read_bufs.next,
-                                 struct acm_rb, list);
-                list_del(&buf->list);
+        dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
+                                        rb->index, urb->actual_length);
+        set_bit(rb->index, &acm->read_urbs_free);
 
-                rcv->buffer = buf;
+        if (!acm->dev) {
+                dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
+                return;
+        }
+        usb_mark_last_busy(acm->dev);
 
-                if (acm->is_int_ep)
-                        usb_fill_int_urb(rcv->urb, acm->dev,
-                                         acm->rx_endpoint,
-                                         buf->base,
-                                         acm->readsize,
-                                         acm_read_bulk, rcv, acm->bInterval);
-                else
-                        usb_fill_bulk_urb(rcv->urb, acm->dev,
-                                          acm->rx_endpoint,
-                                          buf->base,
-                                          acm->readsize,
-                                          acm_read_bulk, rcv);
-                rcv->urb->transfer_dma = buf->dma;
-                rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-
-                /* This shouldn't kill the driver as unsuccessful URBs are
-                   returned to the free-urbs-pool and resubmited ASAP */
-                spin_lock_irqsave(&acm->read_lock, flags);
-                if (acm->susp_count ||
-                                usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
-                        list_add(&buf->list, &acm->spare_read_bufs);
-                        list_add(&rcv->list, &acm->spare_read_urbs);
-                        acm->processing = 0;
-                        spin_unlock_irqrestore(&acm->read_lock, flags);
-                        return;
-                } else {
-                        spin_unlock_irqrestore(&acm->read_lock, flags);
-                        dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
-                }
+        if (urb->status) {
+                dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
+                                                        __func__, urb->status);
+                return;
         }
+        acm_process_read_urb(acm, urb);
+
+        /* throttle device if requested by tty */
         spin_lock_irqsave(&acm->read_lock, flags);
-        acm->processing = 0;
-        spin_unlock_irqrestore(&acm->read_lock, flags);
+        acm->throttled = acm->throttle_req;
+        if (!acm->throttled && !acm->susp_count) {
+                spin_unlock_irqrestore(&acm->read_lock, flags);
+                acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
+        } else {
+                spin_unlock_irqrestore(&acm->read_lock, flags);
+        }
 }
 
 /* data interface wrote those outgoing bytes */
@@ -509,9 +419,9 @@ static void acm_write_bulk(struct urb *urb)
         struct acm *acm = wb->instance;
         unsigned long flags;
 
-        if (verbose || urb->status
-                        || (urb->actual_length != urb->transfer_buffer_length))
-                dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
+        if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
+                dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
+                        __func__,
                         urb->actual_length,
                         urb->transfer_buffer_length,
                         urb->status);
@@ -521,8 +431,6 @@ static void acm_write_bulk(struct urb *urb)
         spin_unlock_irqrestore(&acm->write_lock, flags);
         if (ACM_READY(acm))
                 schedule_work(&acm->work);
-        else
-                wake_up_interruptible(&acm->drain_wait);
 }
 
 static void acm_softint(struct work_struct *work)
@@ -530,7 +438,8 @@ static void acm_softint(struct work_struct *work)
         struct acm *acm = container_of(work, struct acm, work);
         struct tty_struct *tty;
 
-        dev_vdbg(&acm->data->dev, "tx work\n");
+        dev_vdbg(&acm->data->dev, "%s\n", __func__);
+
         if (!ACM_READY(acm))
                 return;
         tty = tty_port_tty_get(&acm->port);
@@ -548,8 +457,6 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 {
         struct acm *acm;
         int rv = -ENODEV;
-        int i;
-        dbg("Entering acm_tty_open.");
 
         mutex_lock(&open_mutex);
 
@@ -559,6 +466,8 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         else
                 rv = 0;
 
+        dev_dbg(&acm->control->dev, "%s\n", __func__);
+
         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 
         tty->driver_data = acm;
@@ -578,38 +487,28 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 
         acm->ctrlurb->dev = acm->dev;
         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
-                dbg("usb_submit_urb(ctrl irq) failed");
+                dev_err(&acm->control->dev,
+                        "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
                 goto bail_out;
         }
 
         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
             (acm->ctrl_caps & USB_CDC_CAP_LINE))
-                goto full_bailout;
+                goto bail_out;
 
         usb_autopm_put_interface(acm->control);
 
-        INIT_LIST_HEAD(&acm->spare_read_urbs);
-        INIT_LIST_HEAD(&acm->spare_read_bufs);
-        INIT_LIST_HEAD(&acm->filled_read_bufs);
-
-        for (i = 0; i < acm->rx_buflimit; i++)
-                list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
-        for (i = 0; i < acm->rx_buflimit; i++)
-                list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
-
-        acm->throttle = 0;
+        if (acm_submit_read_urbs(acm, GFP_KERNEL))
+                goto bail_out;
 
         set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
         rv = tty_port_block_til_ready(&acm->port, tty, filp);
-        tasklet_schedule(&acm->urb_task);
 
         mutex_unlock(&acm->mutex);
 out:
         mutex_unlock(&open_mutex);
         return rv;
 
-full_bailout:
-        usb_kill_urb(acm->ctrlurb);
 bail_out:
         acm->port.count--;
         mutex_unlock(&acm->mutex);
@@ -622,26 +521,24 @@ early_bail:
 
 static void acm_tty_unregister(struct acm *acm)
 {
-        int i, nr;
+        int i;
 
-        nr = acm->rx_buflimit;
         tty_unregister_device(acm_tty_driver, acm->minor);
         usb_put_intf(acm->control);
         acm_table[acm->minor] = NULL;
         usb_free_urb(acm->ctrlurb);
         for (i = 0; i < ACM_NW; i++)
                 usb_free_urb(acm->wb[i].urb);
-        for (i = 0; i < nr; i++)
-                usb_free_urb(acm->ru[i].urb);
+        for (i = 0; i < acm->rx_buflimit; i++)
+                usb_free_urb(acm->read_urbs[i]);
         kfree(acm->country_codes);
         kfree(acm);
 }
 
-static int acm_tty_chars_in_buffer(struct tty_struct *tty);
-
 static void acm_port_down(struct acm *acm)
 {
-        int i, nr = acm->rx_buflimit;
+        int i;
+
         mutex_lock(&open_mutex);
         if (acm->dev) {
                 usb_autopm_get_interface(acm->control);
@@ -649,10 +546,8 @@ static void acm_port_down(struct acm *acm)
                 usb_kill_urb(acm->ctrlurb);
                 for (i = 0; i < ACM_NW; i++)
                         usb_kill_urb(acm->wb[i].urb);
-                tasklet_disable(&acm->urb_task);
-                for (i = 0; i < nr; i++)
-                        usb_kill_urb(acm->ru[i].urb);
-                tasklet_enable(&acm->urb_task);
+                for (i = 0; i < acm->rx_buflimit; i++)
+                        usb_kill_urb(acm->read_urbs[i]);
                 acm->control->needs_remote_wakeup = 0;
                 usb_autopm_put_interface(acm->control);
         }
@@ -698,13 +593,13 @@ static int acm_tty_write(struct tty_struct *tty,
         int wbn;
         struct acm_wb *wb;
 
-        dbg("Entering acm_tty_write to write %d bytes,", count);
-
         if (!ACM_READY(acm))
                 return -EINVAL;
         if (!count)
                 return 0;
 
+        dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
+
         spin_lock_irqsave(&acm->write_lock, flags);
         wbn = acm_wb_alloc(acm);
         if (wbn < 0) {
@@ -714,7 +609,7 @@ static int acm_tty_write(struct tty_struct *tty,
         wb = &acm->wb[wbn];
 
         count = (count > acm->writesize) ? acm->writesize : count;
-        dbg("Get %d bytes...", count);
+        dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
         memcpy(wb->buf, buf, count);
         wb->len = count;
         spin_unlock_irqrestore(&acm->write_lock, flags);
@@ -751,22 +646,31 @@ static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 static void acm_tty_throttle(struct tty_struct *tty)
 {
         struct acm *acm = tty->driver_data;
+
         if (!ACM_READY(acm))
                 return;
-        spin_lock_bh(&acm->throttle_lock);
-        acm->throttle = 1;
-        spin_unlock_bh(&acm->throttle_lock);
+
+        spin_lock_irq(&acm->read_lock);
+        acm->throttle_req = 1;
+        spin_unlock_irq(&acm->read_lock);
 }
 
 static void acm_tty_unthrottle(struct tty_struct *tty)
 {
         struct acm *acm = tty->driver_data;
+        unsigned int was_throttled;
+
         if (!ACM_READY(acm))
                 return;
-        spin_lock_bh(&acm->throttle_lock);
-        acm->throttle = 0;
-        spin_unlock_bh(&acm->throttle_lock);
-        tasklet_schedule(&acm->urb_task);
+
+        spin_lock_irq(&acm->read_lock);
+        was_throttled = acm->throttled;
+        acm->throttled = 0;
+        acm->throttle_req = 0;
+        spin_unlock_irq(&acm->read_lock);
+
+        if (was_throttled)
+                acm_submit_read_urbs(acm, GFP_KERNEL);
 }
 
 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
@@ -777,7 +681,8 @@ static int acm_tty_break_ctl(struct tty_struct *tty, int state)
                 return -EINVAL;
         retval = acm_send_break(acm, state ? 0xffff : 0);
         if (retval < 0)
-                dbg("send break failed");
+                dev_dbg(&acm->control->dev, "%s - send break failed\n",
+                                                                __func__);
         return retval;
 }
 
@@ -872,7 +777,9 @@ static void acm_tty_set_termios(struct tty_struct *tty,
 
         if (memcmp(&acm->line, &newline, sizeof newline)) {
                 memcpy(&acm->line, &newline, sizeof newline);
-                dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
+                dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
+                        __func__,
+                        le32_to_cpu(newline.dwDTERate),
                         newline.bCharFormat, newline.bParityType,
                         newline.bDataBits);
                 acm_set_line(acm, &acm->line);
@@ -897,11 +804,11 @@ static void acm_write_buffers_free(struct acm *acm)
 static void acm_read_buffers_free(struct acm *acm)
 {
         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
-        int i, n = acm->rx_buflimit;
+        int i;
 
-        for (i = 0; i < n; i++)
+        for (i = 0; i < acm->rx_buflimit; i++)
                 usb_free_coherent(usb_dev, acm->readsize,
-                                  acm->rb[i].base, acm->rb[i].dma);
+                          acm->read_buffers[i].base, acm->read_buffers[i].dma);
 }
 
 /* Little helper: write buffers allocate */
@@ -1133,7 +1040,7 @@ skip_normal_probe:
                 epwrite = t;
         }
 made_compressed_probe:
-        dbg("interfaces are valid");
+        dev_dbg(&intf->dev, "interfaces are valid\n");
         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 
         if (minor == ACM_TTY_MINORS) {
@@ -1143,7 +1050,7 @@ made_compressed_probe:
 
         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
         if (acm == NULL) {
-                dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
+                dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
                 goto alloc_fail;
         }
 
@@ -1162,11 +1069,7 @@ made_compressed_probe:
         acm->ctrlsize = ctrlsize;
         acm->readsize = readsize;
         acm->rx_buflimit = num_rx_buf;
-        acm->urb_task.func = acm_rx_tasklet;
-        acm->urb_task.data = (unsigned long) acm;
         INIT_WORK(&acm->work, acm_softint);
-        init_waitqueue_head(&acm->drain_wait);
-        spin_lock_init(&acm->throttle_lock);
         spin_lock_init(&acm->write_lock);
         spin_lock_init(&acm->read_lock);
         mutex_init(&acm->mutex);
@@ -1179,53 +1082,69 @@ made_compressed_probe:
 
         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
         if (!buf) {
-                dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
+                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) {
-                dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
+                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) {
-                dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
+                dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
                 goto alloc_fail5;
         }
         for (i = 0; i < num_rx_buf; i++) {
-                struct acm_ru *rcv = &(acm->ru[i]);
+                struct acm_rb *rb = &(acm->read_buffers[i]);
+                struct urb *urb;
 
-                rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
-                if (rcv->urb == NULL) {
-                        dev_dbg(&intf->dev,
-                                "out of memory (read urbs usb_alloc_urb)\n");
+                rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
+                                                                &rb->dma);
+                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;
 
-                rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-                rcv->instance = acm;
-        }
-        for (i = 0; i < num_rx_buf; i++) {
-                struct acm_rb *rb = &(acm->rb[i]);
-
-                rb->base = usb_alloc_coherent(acm->dev, readsize,
-                                GFP_KERNEL, &rb->dma);
-                if (!rb->base) {
-                        dev_dbg(&intf->dev,
-                                "out of memory (read bufs usb_alloc_coherent)\n");
-                        goto alloc_fail7;
+                urb = usb_alloc_urb(0, GFP_KERNEL);
+                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) {
+                        usb_fill_int_urb(urb, acm->dev,
+                                         acm->rx_endpoint,
+                                         rb->base,
+                                         acm->readsize,
+                                         acm_read_bulk_callback, rb,
+                                         acm->bInterval);
+                } else {
+                        usb_fill_bulk_urb(urb, acm->dev,
+                                          acm->rx_endpoint,
+                                          rb->base,
+                                          acm->readsize,
+                                          acm_read_bulk_callback, rb);
                 }
+
+                acm->read_urbs[i] = urb;
+                __set_bit(i, &acm->read_urbs_free);
         }
         for (i = 0; i < ACM_NW; i++) {
                 struct acm_wb *snd = &(acm->wb[i]);
 
                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
                 if (snd->urb == NULL) {
-                        dev_dbg(&intf->dev,
-                                "out of memory (write urbs usb_alloc_urb)");
-                        goto alloc_fail8;
+                        dev_err(&intf->dev,
+                                "out of memory (write urbs usb_alloc_urb)\n");
+                        goto alloc_fail7;
                 }
 
                 if (usb_endpoint_xfer_int(epwrite))
@@ -1244,7 +1163,7 @@ made_compressed_probe:
 
         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
         if (i < 0)
-                goto alloc_fail8;
+                goto alloc_fail7;
 
         if (cfd) { /* export the country data */
                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
@@ -1296,14 +1215,13 @@ skip_countries:
         acm_table[minor] = acm;
 
         return 0;
-alloc_fail8:
+alloc_fail7:
         for (i = 0; i < ACM_NW; i++)
                 usb_free_urb(acm->wb[i].urb);
-alloc_fail7:
-        acm_read_buffers_free(acm);
 alloc_fail6:
         for (i = 0; i < num_rx_buf; i++)
-                usb_free_urb(acm->ru[i].urb);
+                usb_free_urb(acm->read_urbs[i]);
+        acm_read_buffers_free(acm);
         usb_free_urb(acm->ctrlurb);
 alloc_fail5:
         acm_write_buffers_free(acm);
@@ -1318,17 +1236,14 @@ alloc_fail:
 static void stop_data_traffic(struct acm *acm)
 {
         int i;
-        dbg("Entering stop_data_traffic");
 
-        tasklet_disable(&acm->urb_task);
+        dev_dbg(&acm->control->dev, "%s\n", __func__);
 
         usb_kill_urb(acm->ctrlurb);
         for (i = 0; i < ACM_NW; i++)
                 usb_kill_urb(acm->wb[i].urb);
         for (i = 0; i < acm->rx_buflimit; i++)
-                usb_kill_urb(acm->ru[i].urb);
-
-        tasklet_enable(&acm->urb_task);
+                usb_kill_urb(acm->read_urbs[i]);
 
         cancel_work_sync(&acm->work);
 }
@@ -1389,11 +1304,9 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
         if (message.event & PM_EVENT_AUTO) {
                 int b;
 
-                spin_lock_irq(&acm->read_lock);
-                spin_lock(&acm->write_lock);
-                b = acm->processing + acm->transmitting;
-                spin_unlock(&acm->write_lock);
-                spin_unlock_irq(&acm->read_lock);
+                spin_lock_irq(&acm->write_lock);
+                b = acm->transmitting;
+                spin_unlock_irq(&acm->write_lock);
                 if (b)
                         return -EBUSY;
         }
@@ -1455,7 +1368,7 @@ static int acm_resume(struct usb_interface *intf)
                 if (rv < 0)
                         goto err_out;
 
-                tasklet_schedule(&acm->urb_task);
+                rv = acm_submit_read_urbs(acm, GFP_NOIO);
         }
 
 err_out:
@@ -1716,8 +1629,7 @@ static int __init acm_init(void)
                 return retval;
         }
 
-        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
-               DRIVER_DESC "\n");
+        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
 
         return 0;
 }
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h
index b4ea54dbf323..7b5c0bd07f80 100644
--- a/drivers/usb/class/cdc-acm.h
+++ b/drivers/usb/class/cdc-acm.h
@@ -72,16 +72,10 @@ struct acm_wb {
 };
 
 struct acm_rb {
-        struct list_head        list;
         int                     size;
         unsigned char           *base;
         dma_addr_t              dma;
-};
-
-struct acm_ru {
-        struct list_head        list;
-        struct acm_rb           *buffer;
-        struct urb              *urb;
+        int                     index;
         struct acm              *instance;
 };
 
@@ -97,35 +91,30 @@ struct acm {
         unsigned int country_code_size;                 /* size of this buffer */
         unsigned int country_rel_date;                  /* release date of version */
         struct acm_wb wb[ACM_NW];
-        struct acm_ru ru[ACM_NR];
-        struct acm_rb rb[ACM_NR];
+        unsigned long read_urbs_free;
+        struct urb *read_urbs[ACM_NR];
+        struct acm_rb read_buffers[ACM_NR];
         int rx_buflimit;
         int rx_endpoint;
         spinlock_t read_lock;
-        struct list_head spare_read_urbs;
-        struct list_head spare_read_bufs;
-        struct list_head filled_read_bufs;
         int write_used;                                 /* number of non-empty write buffers */
-        int processing;
         int transmitting;
         spinlock_t write_lock;
         struct mutex mutex;
         struct usb_cdc_line_coding line;                /* bits, stop, parity */
         struct work_struct work;                        /* work queue entry for line discipline waking up */
-        wait_queue_head_t drain_wait;                   /* close processing */
-        struct tasklet_struct urb_task;                 /* rx processing */
-        spinlock_t throttle_lock;                       /* synchronize throtteling and read callback */
         unsigned int ctrlin;                            /* input control lines (DCD, DSR, RI, break, overruns) */
         unsigned int ctrlout;                           /* output control lines (DTR, RTS) */
         unsigned int writesize;                         /* max packet size for the output bulk endpoint */
         unsigned int readsize,ctrlsize;                 /* buffer sizes for freeing */
         unsigned int minor;                             /* acm minor number */
-        unsigned char throttle;                         /* throttled by tty layer */
         unsigned char clocal;                           /* termios CLOCAL */
         unsigned int ctrl_caps;                         /* control capabilities from the class specific header */
         unsigned int susp_count;                        /* number of suspended interfaces */
         unsigned int combined_interfaces:1;             /* control and data collapsed */
         unsigned int is_int_ep:1;                       /* interrupt endpoints contrary to spec used */
+        unsigned int throttled:1;                       /* actually throttled */
+        unsigned int throttle_req:1;                    /* throttle requested */
         u8 bInterval;
         struct acm_wb *delayed_wb;                      /* write queued for a device about to be woken */
 };
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index a97c018dd419..2b9ff518b509 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -542,6 +542,8 @@ static int wdm_open(struct inode *inode, struct file *file)
 
         mutex_lock(&desc->lock);
         if (!desc->count++) {
+                desc->werr = 0;
+                desc->rerr = 0;
                 rv = usb_submit_urb(desc->validity, GFP_KERNEL);
                 if (rv < 0) {
                         desc->count--;
@@ -853,6 +855,18 @@ static int wdm_pre_reset(struct usb_interface *intf)
         struct wdm_device *desc = usb_get_intfdata(intf);
 
         mutex_lock(&desc->lock);
+        kill_urbs(desc);
+
+        /*
+         * we notify everybody using poll of
+         * an exceptional situation
+         * must be done before recovery lest a spontaneous
+         * message from the device is lost
+         */
+        spin_lock_irq(&desc->iuspin);
+        desc->rerr = -EINTR;
+        spin_unlock_irq(&desc->iuspin);
+        wake_up_all(&desc->wait);
         return 0;
 }
 
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index 83126b03e7cf..c962608b4b9a 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -129,7 +129,7 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
                 max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1);
         else
                 max_tx = 999999;
-        if (desc->wBytesPerInterval > max_tx) {
+        if (le16_to_cpu(desc->wBytesPerInterval) > max_tx) {
                 dev_warn(ddev, "%s endpoint with wBytesPerInterval of %d in "
                                 "config %d interface %d altsetting %d ep %d: "
                                 "setting to %d\n",
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index 96fdfb815f89..0149c0976e9c 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -64,49 +64,49 @@
 /* Define ALLOW_SERIAL_NUMBER if you want to see the serial number of devices */
 #define ALLOW_SERIAL_NUMBER
 
-static const char *format_topo =
+static const char format_topo[] =
 /* T:  Bus=dd Lev=dd Prnt=dd Port=dd Cnt=dd Dev#=ddd Spd=dddd MxCh=dd */
 "\nT:  Bus=%2.2d Lev=%2.2d Prnt=%2.2d Port=%2.2d Cnt=%2.2d Dev#=%3d Spd=%-4s MxCh=%2d\n";
 
-static const char *format_string_manufacturer =
+static const char format_string_manufacturer[] =
 /* S:  Manufacturer=xxxx */
   "S:  Manufacturer=%.100s\n";
 
-static const char *format_string_product =
+static const char format_string_product[] =
 /* S:  Product=xxxx */
   "S:  Product=%.100s\n";
 
 #ifdef ALLOW_SERIAL_NUMBER
-static const char *format_string_serialnumber =
+static const char format_string_serialnumber[] =
 /* S:  SerialNumber=xxxx */
   "S:  SerialNumber=%.100s\n";
 #endif
 
-static const char *format_bandwidth =
+static const char format_bandwidth[] =
 /* B:  Alloc=ddd/ddd us (xx%), #Int=ddd, #Iso=ddd */
   "B:  Alloc=%3d/%3d us (%2d%%), #Int=%3d, #Iso=%3d\n";
 
-static const char *format_device1 =
+static const char format_device1[] =
 /* D:  Ver=xx.xx Cls=xx(sssss) Sub=xx Prot=xx MxPS=dd #Cfgs=dd */
   "D:  Ver=%2x.%02x Cls=%02x(%-5s) Sub=%02x Prot=%02x MxPS=%2d #Cfgs=%3d\n";
 
-static const char *format_device2 =
+static const char format_device2[] =
 /* P:  Vendor=xxxx ProdID=xxxx Rev=xx.xx */
   "P:  Vendor=%04x ProdID=%04x Rev=%2x.%02x\n";
 
-static const char *format_config =
+static const char format_config[] =
 /* C:  #Ifs=dd Cfg#=dd Atr=xx MPwr=dddmA */
   "C:%c #Ifs=%2d Cfg#=%2d Atr=%02x MxPwr=%3dmA\n";
 
-static const char *format_iad =
+static const char format_iad[] =
 /* A:  FirstIf#=dd IfCount=dd Cls=xx(sssss) Sub=xx Prot=xx */
   "A:  FirstIf#=%2d IfCount=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x\n";
 
-static const char *format_iface =
+static const char format_iface[] =
 /* I:  If#=dd Alt=dd #EPs=dd Cls=xx(sssss) Sub=xx Prot=xx Driver=xxxx*/
   "I:%c If#=%2d Alt=%2d #EPs=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x Driver=%s\n";
 
-static const char *format_endpt =
+static const char format_endpt[] =
 /* E:  Ad=xx(s) Atr=xx(ssss) MxPS=dddd Ivl=D?s */
   "E:  Ad=%02x(%c) Atr=%02x(%-4s) MxPS=%4d Ivl=%d%cs\n";
 
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index cf6a5423de09..99458c843d60 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -236,13 +236,6 @@ EXPORT_SYMBOL_GPL(usb_register_dev);
 void usb_deregister_dev(struct usb_interface *intf,
                         struct usb_class_driver *class_driver)
 {
-        int minor_base = class_driver->minor_base;
-        char name[20];
-
-#ifdef CONFIG_USB_DYNAMIC_MINORS
-        minor_base = 0;
-#endif
-
         if (intf->minor == -1)
                 return;
 
@@ -252,7 +245,6 @@ void usb_deregister_dev(struct usb_interface *intf,
         usb_minors[intf->minor] = NULL;
         up_write(&minor_rwsem);
 
-        snprintf(name, sizeof(name), class_driver->name, intf->minor - minor_base);
         device_destroy(usb_class->class, MKDEV(USB_MAJOR, intf->minor));
         intf->usb_dev = NULL;
         intf->minor = -1;
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 77a7faec8d78..10936ba9c42b 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -2407,6 +2407,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
                 rhdev->speed = USB_SPEED_SUPER;
                 break;
         default:
+                retval = -EINVAL;
                 goto err_set_rh_speed;
         }
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 93720bdc9efd..79a58c3a2e2a 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -379,15 +379,6 @@ static int hub_port_status(struct usb_hub *hub, int port1,
                 *status = le16_to_cpu(hub->status->port.wPortStatus);
                 *change = le16_to_cpu(hub->status->port.wPortChange);
 
-                if ((hub->hdev->parent != NULL) &&
-                                hub_is_superspeed(hub->hdev)) {
-                        /* Translate the USB 3 port status */
-                        u16 tmp = *status & USB_SS_PORT_STAT_MASK;
-                        if (*status & USB_SS_PORT_STAT_POWER)
-                                tmp |= USB_PORT_STAT_POWER;
-                        *status = tmp;
-                }
-
                 ret = 0;
         }
         mutex_unlock(&hub->status_mutex);
@@ -2160,11 +2151,76 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
         return status;
 }
 
+/* Warm reset a USB3 protocol port */
+static int hub_port_warm_reset(struct usb_hub *hub, int port)
+{
+        int ret;
+        u16 portstatus, portchange;
+
+        if (!hub_is_superspeed(hub->hdev)) {
+                dev_err(hub->intfdev, "only USB3 hub support warm reset\n");
+                return -EINVAL;
+        }
+
+        /* Warm reset the port */
+        ret = set_port_feature(hub->hdev,
+                                port, USB_PORT_FEAT_BH_PORT_RESET);
+        if (ret) {
+                dev_err(hub->intfdev, "cannot warm reset port %d\n", port);
+                return ret;
+        }
+
+        msleep(20);
+        ret = hub_port_status(hub, port, &portstatus, &portchange);
+
+        if (portchange & USB_PORT_STAT_C_RESET)
+                clear_port_feature(hub->hdev, port, USB_PORT_FEAT_C_RESET);
+
+        if (portchange & USB_PORT_STAT_C_BH_RESET)
+                clear_port_feature(hub->hdev, port,
+                                        USB_PORT_FEAT_C_BH_PORT_RESET);
+
+        if (portchange & USB_PORT_STAT_C_LINK_STATE)
+                clear_port_feature(hub->hdev, port,
+                                        USB_PORT_FEAT_C_PORT_LINK_STATE);
+
+        return ret;
+}
+
+/* Check if a port is power on */
+static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
+{
+        int ret = 0;
+
+        if (hub_is_superspeed(hub->hdev)) {
+                if (portstatus & USB_SS_PORT_STAT_POWER)
+                        ret = 1;
+        } else {
+                if (portstatus & USB_PORT_STAT_POWER)
+                        ret = 1;
+        }
+
+        return ret;
+}
+
 #ifdef  CONFIG_PM
 
-#define MASK_BITS       (USB_PORT_STAT_POWER | USB_PORT_STAT_CONNECTION | \
-                                USB_PORT_STAT_SUSPEND)
-#define WANT_BITS       (USB_PORT_STAT_POWER | USB_PORT_STAT_CONNECTION)
+/* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
+static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
+{
+        int ret = 0;
+
+        if (hub_is_superspeed(hub->hdev)) {
+                if ((portstatus & USB_PORT_STAT_LINK_STATE)
+                                == USB_SS_PORT_LS_U3)
+                        ret = 1;
+        } else {
+                if (portstatus & USB_PORT_STAT_SUSPEND)
+                        ret = 1;
+        }
+
+        return ret;
+}
 
 /* Determine whether the device on a port is ready for a normal resume,
  * is ready for a reset-resume, or should be disconnected.
@@ -2174,7 +2230,9 @@ static int check_port_resume_type(struct usb_device *udev,
                 int status, unsigned portchange, unsigned portstatus)
 {
         /* Is the device still present? */
-        if (status || (portstatus & MASK_BITS) != WANT_BITS) {
+        if (status || port_is_suspended(hub, portstatus) ||
+                        !port_is_power_on(hub, portstatus) ||
+                        !(portstatus & USB_PORT_STAT_CONNECTION)) {
                 if (status >= 0)
                         status = -ENODEV;
         }
@@ -2285,14 +2343,10 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
         }
 
         /* see 7.1.7.6 */
-        /* Clear PORT_POWER if it's a USB3.0 device connected to USB 3.0
-         * external hub.
-         * FIXME: this is a temporary workaround to make the system able
-         * to suspend/resume.
-         */
-        if ((hub->hdev->parent != NULL) && hub_is_superspeed(hub->hdev))
-                status = clear_port_feature(hub->hdev, port1,
-                                                USB_PORT_FEAT_POWER);
+        if (hub_is_superspeed(hub->hdev))
+                status = set_port_feature(hub->hdev,
+                                port1 | (USB_SS_PORT_LS_U3 << 3),
+                                USB_PORT_FEAT_LINK_STATE);
         else
                 status = set_port_feature(hub->hdev, port1,
                                                 USB_PORT_FEAT_SUSPEND);
@@ -2439,7 +2493,7 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 
         /* Skip the initial Clear-Suspend step for a remote wakeup */
         status = hub_port_status(hub, port1, &portstatus, &portchange);
-        if (status == 0 && !(portstatus & USB_PORT_STAT_SUSPEND))
+        if (status == 0 && !port_is_suspended(hub, portstatus))
                 goto SuspendCleared;
 
         // dev_dbg(hub->intfdev, "resume port %d\n", port1);
@@ -2447,8 +2501,13 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         set_bit(port1, hub->busy_bits);
 
         /* see 7.1.7.7; affects power usage, but not budgeting */
-        status = clear_port_feature(hub->hdev,
-                        port1, USB_PORT_FEAT_SUSPEND);
+        if (hub_is_superspeed(hub->hdev))
+                status = set_port_feature(hub->hdev,
+                                port1 | (USB_SS_PORT_LS_U0 << 3),
+                                USB_PORT_FEAT_LINK_STATE);
+        else
+                status = clear_port_feature(hub->hdev,
+                                port1, USB_PORT_FEAT_SUSPEND);
         if (status) {
                 dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
                                 port1, status);
@@ -2470,9 +2529,15 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 
  SuspendCleared:
         if (status == 0) {
-                if (portchange & USB_PORT_STAT_C_SUSPEND)
-                        clear_port_feature(hub->hdev, port1,
-                                        USB_PORT_FEAT_C_SUSPEND);
+                if (hub_is_superspeed(hub->hdev)) {
+                        if (portchange & USB_PORT_STAT_C_LINK_STATE)
+                                clear_port_feature(hub->hdev, port1,
+                                        USB_PORT_FEAT_C_PORT_LINK_STATE);
+                } else {
+                        if (portchange & USB_PORT_STAT_C_SUSPEND)
+                                clear_port_feature(hub->hdev, port1,
+                                                USB_PORT_FEAT_C_SUSPEND);
+                }
         }
 
         clear_bit(port1, hub->busy_bits);
@@ -3147,7 +3212,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
 
                 /* maybe switch power back on (e.g. root hub was reset) */
                 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
-                                && !(portstatus & USB_PORT_STAT_POWER))
+                                && !port_is_power_on(hub, portstatus))
                         set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 
                 if (portstatus & USB_PORT_STAT_ENABLE)
@@ -3490,6 +3555,16 @@ static void hub_events(void)
                                                 USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
                         }
 
+                        /* Warm reset a USB3 protocol port if it's in
+                         * SS.Inactive state.
+                         */
+                        if (hub_is_superspeed(hub->hdev) &&
+                                (portstatus & USB_PORT_STAT_LINK_STATE)
+                                        == USB_SS_PORT_LS_SS_INACTIVE) {
+                                dev_dbg(hub_dev, "warm reset port %d\n", i);
+                                hub_port_warm_reset(hub, i);
+                        }
+
                         if (connect_change)
                                 hub_port_connect_change(hub, i,
                                                 portstatus, portchange);
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 6781c369ce2d..cf05b97693ea 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -842,22 +842,19 @@ const struct attribute_group *usb_interface_groups[] = {
         NULL
 };
 
-int usb_create_sysfs_intf_files(struct usb_interface *intf)
+void usb_create_sysfs_intf_files(struct usb_interface *intf)
 {
         struct usb_device *udev = interface_to_usbdev(intf);
         struct usb_host_interface *alt = intf->cur_altsetting;
-        int retval;
 
         if (intf->sysfs_files_created || intf->unregistering)
-                return 0;
+                return;
 
-        if (alt->string == NULL &&
-                        !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
+        if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
-        if (alt->string)
-                retval = device_create_file(&intf->dev, &dev_attr_interface);
+        if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
+                ;       /* We don't actually care if the function fails. */
         intf->sysfs_files_created = 1;
-        return 0;
 }
 
 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index d9d4b169404f..8706fc97e60f 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -953,8 +953,7 @@ static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
                 if (dev->type == &usb_device_type)
                         (void) usb_create_sysfs_dev_files(to_usb_device(dev));
                 else if (dev->type == &usb_if_device_type)
-                        (void) usb_create_sysfs_intf_files(
-                                        to_usb_interface(dev));
+                        usb_create_sysfs_intf_files(to_usb_interface(dev));
                 break;
 
         case BUS_NOTIFY_DEL_DEVICE:
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index d450b742137e..d44d4b7bbf17 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -4,7 +4,7 @@
 
 extern int usb_create_sysfs_dev_files(struct usb_device *dev);
 extern void usb_remove_sysfs_dev_files(struct usb_device *dev);
-extern int usb_create_sysfs_intf_files(struct usb_interface *intf);
+extern void usb_create_sysfs_intf_files(struct usb_interface *intf);
 extern void usb_remove_sysfs_intf_files(struct usb_interface *intf);
 extern int usb_create_ep_devs(struct device *parent,
                                 struct usb_host_endpoint *endpoint,
diff --git a/drivers/usb/early/ehci-dbgp.c b/drivers/usb/early/ehci-dbgp.c
index a6a350f5827b..1fc8f1249806 100644
--- a/drivers/usb/early/ehci-dbgp.c
+++ b/drivers/usb/early/ehci-dbgp.c
@@ -102,6 +102,9 @@ static struct kgdb_io kgdbdbgp_io_ops;
 #define dbgp_kgdb_mode (0)
 #endif
 
+/* Local version of HC_LENGTH macro as ehci struct is not available here */
+#define EARLY_HC_LENGTH(p)      (0x00ff & (p)) /* bits 7 : 0 */
+
 /*
  * USB Packet IDs (PIDs)
  */
@@ -892,7 +895,7 @@ int __init early_dbgp_init(char *s)
         dbgp_printk("ehci_bar: %p\n", ehci_bar);
 
         ehci_caps  = ehci_bar;
-        ehci_regs  = ehci_bar + HC_LENGTH(readl(&ehci_caps->hc_capbase));
+        ehci_regs  = ehci_bar + EARLY_HC_LENGTH(readl(&ehci_caps->hc_capbase));
         ehci_debug = ehci_bar + offset;
         ehci_dev.bus = bus;
         ehci_dev.slot = slot;
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index bc5123cf41c2..4c02b9f1597e 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -260,6 +260,24 @@ config USB_R8A66597
         default USB_GADGET
         select USB_GADGET_SELECTED
 
+config USB_GADGET_RENESAS_USBHS
+        boolean "Renesas USBHS"
+        depends on USB_RENESAS_USBHS
+        select USB_GADGET_DUALSPEED
+        help
+           Renesas USBHS is a discrete USB host and peripheral controller
+           chip that supports both full and high speed USB 2.0 data transfers.
+           platform is able to configure endpoint (pipe) style
+
+           Say "y" to enable the gadget specific portion of the USBHS driver.
+
+
+config USB_RENESAS_USBHS_UDC
+        tristate
+        depends on USB_GADGET_RENESAS_USBHS
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 config USB_GADGET_PXA27X
         boolean "PXA 27x"
         depends on ARCH_PXA && (PXA27x || PXA3xx)
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c
index e09178bc1450..baaf87ed7685 100644
--- a/drivers/usb/gadget/ci13xxx_udc.c
+++ b/drivers/usb/gadget/ci13xxx_udc.c
@@ -310,7 +310,7 @@ static int hw_device_reset(struct ci13xxx *udc)
                 udc->udc_driver->notify_event(udc,
                         CI13XXX_CONTROLLER_RESET_EVENT);
 
-        if (udc->udc_driver->flags && CI13XXX_DISABLE_STREAMING)
+        if (udc->udc_driver->flags & CI13XXX_DISABLE_STREAMING)
                 hw_cwrite(CAP_USBMODE, USBMODE_SDIS, USBMODE_SDIS);
 
         /* USBMODE should be configured step by step */
@@ -1634,8 +1634,6 @@ static int _gadget_stop_activity(struct usb_gadget *gadget)
         gadget_for_each_ep(ep, gadget) {
                 usb_ep_disable(ep);
         }
-        usb_ep_disable(&udc->ep0out.ep);
-        usb_ep_disable(&udc->ep0in.ep);
 
         if (udc->status != NULL) {
                 usb_ep_free_request(&udc->ep0in.ep, udc->status);
@@ -1678,18 +1676,10 @@ __acquires(udc->lock)
         if (retval)
                 goto done;
 
-        retval = usb_ep_enable(&udc->ep0out.ep, &ctrl_endpt_out_desc);
-        if (retval)
-                goto done;
+        udc->status = usb_ep_alloc_request(&udc->ep0in.ep, GFP_ATOMIC);
+        if (udc->status == NULL)
+                retval = -ENOMEM;
 
-        retval = usb_ep_enable(&udc->ep0in.ep, &ctrl_endpt_in_desc);
-        if (!retval) {
-                udc->status = usb_ep_alloc_request(&udc->ep0in.ep, GFP_ATOMIC);
-                if (udc->status == NULL) {
-                        usb_ep_disable(&udc->ep0out.ep);
-                        retval = -ENOMEM;
-                }
-        }
         spin_lock(udc->lock);
 
  done:
@@ -1843,7 +1833,8 @@ __releases(mEp->lock)
 __acquires(mEp->lock)
 {
         struct ci13xxx_req *mReq, *mReqTemp;
-        int retval;
+        struct ci13xxx_ep *mEpTemp = mEp;
+        int uninitialized_var(retval);
 
         trace("%p", mEp);
 
@@ -1859,12 +1850,15 @@ __acquires(mEp->lock)
                 dbg_done(_usb_addr(mEp), mReq->ptr->token, retval);
                 if (mReq->req.complete != NULL) {
                         spin_unlock(mEp->lock);
-                        mReq->req.complete(&mEp->ep, &mReq->req);
+                        if ((mEp->type == USB_ENDPOINT_XFER_CONTROL) &&
+                                        mReq->req.length)
+                                mEpTemp = &_udc->ep0in;
+                        mReq->req.complete(&mEpTemp->ep, &mReq->req);
                         spin_lock(mEp->lock);
                 }
         }
 
-        if (retval == EBUSY)
+        if (retval == -EBUSY)
                 retval = 0;
         if (retval < 0)
                 dbg_event(_usb_addr(mEp), "DONE", retval);
@@ -1894,7 +1888,7 @@ __acquires(udc->lock)
 
         for (i = 0; i < hw_ep_max; i++) {
                 struct ci13xxx_ep *mEp  = &udc->ci13xxx_ep[i];
-                int type, num, err = -EINVAL;
+                int type, num, dir, err = -EINVAL;
                 struct usb_ctrlrequest req;
 
                 if (mEp->desc == NULL)
@@ -1952,7 +1946,10 @@ __acquires(udc->lock)
                                 if (req.wLength != 0)
                                         break;
                                 num  = le16_to_cpu(req.wIndex);
+                                dir = num & USB_ENDPOINT_DIR_MASK;
                                 num &= USB_ENDPOINT_NUMBER_MASK;
+                                if (dir) /* TX */
+                                        num += hw_ep_max/2;
                                 if (!udc->ci13xxx_ep[num].wedge) {
                                         spin_unlock(udc->lock);
                                         err = usb_ep_clear_halt(
@@ -2001,7 +1998,10 @@ __acquires(udc->lock)
                                 if (req.wLength != 0)
                                         break;
                                 num  = le16_to_cpu(req.wIndex);
+                                dir = num & USB_ENDPOINT_DIR_MASK;
                                 num &= USB_ENDPOINT_NUMBER_MASK;
+                                if (dir) /* TX */
+                                        num += hw_ep_max/2;
 
                                 spin_unlock(udc->lock);
                                 err = usb_ep_set_halt(&udc->ci13xxx_ep[num].ep);
@@ -2110,7 +2110,12 @@ static int ep_enable(struct usb_ep *ep,
                 (mEp->ep.maxpacket << ffs_nr(QH_MAX_PKT)) & QH_MAX_PKT;
         mEp->qh.ptr->td.next |= TD_TERMINATE;   /* needed? */
 
-        retval |= hw_ep_enable(mEp->num, mEp->dir, mEp->type);
+        /*
+         * Enable endpoints in the HW other than ep0 as ep0
+         * is always enabled
+         */
+        if (mEp->num)
+                retval |= hw_ep_enable(mEp->num, mEp->dir, mEp->type);
 
         spin_unlock_irqrestore(mEp->lock, flags);
         return retval;
@@ -2242,11 +2247,15 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
 
         spin_lock_irqsave(mEp->lock, flags);
 
-        if (mEp->type == USB_ENDPOINT_XFER_CONTROL &&
-            !list_empty(&mEp->qh.queue)) {
-                _ep_nuke(mEp);
-                retval = -EOVERFLOW;
-                warn("endpoint ctrl %X nuked", _usb_addr(mEp));
+        if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
+                if (req->length)
+                        mEp = (_udc->ep0_dir == RX) ?
+                                &_udc->ep0out : &_udc->ep0in;
+                if (!list_empty(&mEp->qh.queue)) {
+                        _ep_nuke(mEp);
+                        retval = -EOVERFLOW;
+                        warn("endpoint ctrl %X nuked", _usb_addr(mEp));
+                }
         }
 
         /* first nuke then test link, e.g. previous status has not sent */
@@ -2497,6 +2506,15 @@ out:
         return ret;
 }
 
+static int ci13xxx_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
+{
+        struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
+
+        if (udc->transceiver)
+                return otg_set_power(udc->transceiver, mA);
+        return -ENOTSUPP;
+}
+
 /**
  * Device operations part of the API to the USB controller hardware,
  * which don't involve endpoints (or i/o)
@@ -2505,6 +2523,7 @@ out:
 static const struct usb_gadget_ops usb_gadget_ops = {
         .vbus_session   = ci13xxx_vbus_session,
         .wakeup         = ci13xxx_wakeup,
+        .vbus_draw      = ci13xxx_vbus_draw,
 };
 
 /**
@@ -2595,6 +2614,14 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
         }
         if (retval)
                 goto done;
+        spin_unlock_irqrestore(udc->lock, flags);
+        retval = usb_ep_enable(&udc->ep0out.ep, &ctrl_endpt_out_desc);
+        if (retval)
+                return retval;
+        retval = usb_ep_enable(&udc->ep0in.ep, &ctrl_endpt_in_desc);
+        if (retval)
+                return retval;
+        spin_lock_irqsave(udc->lock, flags);
 
         udc->gadget.ep0 = &udc->ep0in.ep;
         /* bind gadget */
diff --git a/drivers/usb/gadget/dbgp.c b/drivers/usb/gadget/dbgp.c
index e5ac8a316fec..dbe92ee88477 100644
--- a/drivers/usb/gadget/dbgp.c
+++ b/drivers/usb/gadget/dbgp.c
@@ -261,8 +261,8 @@ static int __init dbgp_configure_endpoints(struct usb_gadget *gadget)
         o_desc.wMaxPacketSize =
                 __constant_cpu_to_le16(USB_DEBUG_MAX_PACKET_SIZE);
 
-        dbg_desc.bDebugInEndpoint = i_desc.bEndpointAddress & 0x7f;
-        dbg_desc.bDebugOutEndpoint = o_desc.bEndpointAddress & 0x7f;
+        dbg_desc.bDebugInEndpoint = i_desc.bEndpointAddress;
+        dbg_desc.bDebugOutEndpoint = o_desc.bEndpointAddress;
 
 #ifdef CONFIG_USB_G_DBGP_SERIAL
         dbgp.serial->in = dbgp.i_ep;
@@ -312,6 +312,7 @@ static int __init dbgp_bind(struct usb_gadget *gadget)
 
         dbgp.req->length = DBGP_REQ_EP0_LEN;
         gadget->ep0->driver_data = gadget;
+        device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
 
 #ifdef CONFIG_USB_G_DBGP_SERIAL
         dbgp.serial = kzalloc(sizeof(struct gserial), GFP_KERNEL);
@@ -350,9 +351,9 @@ static int dbgp_setup(struct usb_gadget *gadget,
         u8 request = ctrl->bRequest;
         u16 value = le16_to_cpu(ctrl->wValue);
         u16 length = le16_to_cpu(ctrl->wLength);
-        int err = 0;
-        void *data;
-        u16 len;
+        int err = -EOPNOTSUPP;
+        void *data = NULL;
+        u16 len = 0;
 
         gadget->ep0->driver_data = gadget;
 
@@ -371,10 +372,9 @@ static int dbgp_setup(struct usb_gadget *gadget,
                 default:
                         goto fail;
                 }
+                err = 0;
         } else if (request == USB_REQ_SET_FEATURE &&
                    value == USB_DEVICE_DEBUG_MODE) {
-                len = 0;
-                data = NULL;
                 dev_dbg(&dbgp.gadget->dev, "setup: feat debug\n");
 #ifdef CONFIG_USB_G_DBGP_PRINTK
                 err = dbgp_enable_ep();
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 3214ca375d64..61ff927928ab 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -892,10 +892,11 @@ static int dummy_udc_probe (struct platform_device *pdev)
                 return rc;
         }
 
-        platform_set_drvdata (pdev, dum);
         rc = device_create_file (&dum->gadget.dev, &dev_attr_function);
         if (rc < 0)
                 device_unregister (&dum->gadget.dev);
+        else
+                platform_set_drvdata(pdev, dum);
         return rc;
 }
 
@@ -1995,11 +1996,29 @@ static int __init init (void)
         retval = platform_device_add(the_hcd_pdev);
         if (retval < 0)
                 goto err_add_hcd;
+        if (!the_controller) {
+                /*
+                 * The hcd was added successfully but its probe function failed
+                 * for some reason.
+                 */
+                retval = -EINVAL;
+                goto err_add_udc;
+        }
         retval = platform_device_add(the_udc_pdev);
         if (retval < 0)
                 goto err_add_udc;
+        if (!platform_get_drvdata(the_udc_pdev)) {
+                /*
+                 * The udc was added successfully but its probe function failed
+                 * for some reason.
+                 */
+                retval = -EINVAL;
+                goto err_probe_udc;
+        }
         return retval;
 
+err_probe_udc:
+        platform_device_del(the_udc_pdev);
 err_add_udc:
         platform_device_del(the_hcd_pdev);
 err_add_hcd:
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index 6d8e533949eb..01ae27b60d4c 100644
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -613,6 +613,11 @@ static int fsg_setup(struct usb_function *f,
         if (!fsg_is_set(fsg->common))
                 return -EOPNOTSUPP;
 
+        ++fsg->common->ep0_req_tag;     /* Record arrival of a new request */
+        req->context = NULL;
+        req->length = 0;
+        dump_msg(fsg, "ep0-setup", (u8 *) ctrl, sizeof(*ctrl));
+
         switch (ctrl->bRequest) {
 
         case USB_BULK_RESET_REQUEST:
@@ -1584,37 +1589,6 @@ static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
         return rc;
 }
 
-static int pad_with_zeros(struct fsg_dev *fsg)
-{
-        struct fsg_buffhd       *bh = fsg->common->next_buffhd_to_fill;
-        u32                     nkeep = bh->inreq->length;
-        u32                     nsend;
-        int                     rc;
-
-        bh->state = BUF_STATE_EMPTY;            /* For the first iteration */
-        fsg->common->usb_amount_left = nkeep + fsg->common->residue;
-        while (fsg->common->usb_amount_left > 0) {
-
-                /* Wait for the next buffer to be free */
-                while (bh->state != BUF_STATE_EMPTY) {
-                        rc = sleep_thread(fsg->common);
-                        if (rc)
-                                return rc;
-                }
-
-                nsend = min(fsg->common->usb_amount_left, FSG_BUFLEN);
-                memset(bh->buf + nkeep, 0, nsend - nkeep);
-                bh->inreq->length = nsend;
-                bh->inreq->zero = 0;
-                start_transfer(fsg, fsg->bulk_in, bh->inreq,
-                               &bh->inreq_busy, &bh->state);
-                bh = fsg->common->next_buffhd_to_fill = bh->next;
-                fsg->common->usb_amount_left -= nsend;
-                nkeep = 0;
-        }
-        return 0;
-}
-
 static int throw_away_data(struct fsg_common *common)
 {
         struct fsg_buffhd       *bh;
@@ -1702,6 +1676,10 @@ static int finish_reply(struct fsg_common *common)
                 if (common->data_size == 0) {
                         /* Nothing to send */
 
+                /* Don't know what to do if common->fsg is NULL */
+                } else if (!fsg_is_set(common)) {
+                        rc = -EIO;
+
                 /* If there's no residue, simply send the last buffer */
                 } else if (common->residue == 0) {
                         bh->inreq->zero = 0;
@@ -1710,24 +1688,19 @@ static int finish_reply(struct fsg_common *common)
                         common->next_buffhd_to_fill = bh->next;
 
                 /*
-                 * For Bulk-only, if we're allowed to stall then send the
-                 * short packet and halt the bulk-in endpoint.  If we can't
-                 * stall, pad out the remaining data with 0's.
+                 * For Bulk-only, mark the end of the data with a short
+                 * packet.  If we are allowed to stall, halt the bulk-in
+                 * endpoint.  (Note: This violates the Bulk-Only Transport
+                 * specification, which requires us to pad the data if we
+                 * don't halt the endpoint.  Presumably nobody will mind.)
                  */
-                } else if (common->can_stall) {
+                } else {
                         bh->inreq->zero = 1;
                         if (!start_in_transfer(common, bh))
-                                /* Don't know what to do if
-                                 * common->fsg is NULL */
                                 rc = -EIO;
                         common->next_buffhd_to_fill = bh->next;
-                        if (common->fsg)
+                        if (common->can_stall)
                                 rc = halt_bulk_in_endpoint(common->fsg);
-                } else if (fsg_is_set(common)) {
-                        rc = pad_with_zeros(common->fsg);
-                } else {
-                        /* Don't know what to do if common->fsg is NULL */
-                        rc = -EIO;
                 }
                 break;
 
@@ -2800,6 +2773,7 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
         for (i = 0, lcfg = cfg->luns; i < nluns; ++i, ++curlun, ++lcfg) {
                 curlun->cdrom = !!lcfg->cdrom;
                 curlun->ro = lcfg->cdrom || lcfg->ro;
+                curlun->initially_ro = curlun->ro;
                 curlun->removable = lcfg->removable;
                 curlun->dev.release = fsg_lun_release;
                 curlun->dev.parent = &gadget->dev;
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index a6eacb59571b..fcfc77c7ad70 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -1947,37 +1947,6 @@ static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
         return rc;
 }
 
-static int pad_with_zeros(struct fsg_dev *fsg)
-{
-        struct fsg_buffhd       *bh = fsg->next_buffhd_to_fill;
-        u32                     nkeep = bh->inreq->length;
-        u32                     nsend;
-        int                     rc;
-
-        bh->state = BUF_STATE_EMPTY;            // For the first iteration
-        fsg->usb_amount_left = nkeep + fsg->residue;
-        while (fsg->usb_amount_left > 0) {
-
-                /* Wait for the next buffer to be free */
-                while (bh->state != BUF_STATE_EMPTY) {
-                        rc = sleep_thread(fsg);
-                        if (rc)
-                                return rc;
-                }
-
-                nsend = min(fsg->usb_amount_left, (u32) mod_data.buflen);
-                memset(bh->buf + nkeep, 0, nsend - nkeep);
-                bh->inreq->length = nsend;
-                bh->inreq->zero = 0;
-                start_transfer(fsg, fsg->bulk_in, bh->inreq,
-                                &bh->inreq_busy, &bh->state);
-                bh = fsg->next_buffhd_to_fill = bh->next;
-                fsg->usb_amount_left -= nsend;
-                nkeep = 0;
-        }
-        return 0;
-}
-
 static int throw_away_data(struct fsg_dev *fsg)
 {
         struct fsg_buffhd       *bh;
@@ -2082,18 +2051,20 @@ static int finish_reply(struct fsg_dev *fsg)
                         }
                 }
 
-                /* For Bulk-only, if we're allowed to stall then send the
-                 * short packet and halt the bulk-in endpoint.  If we can't
-                 * stall, pad out the remaining data with 0's. */
+                /*
+                 * For Bulk-only, mark the end of the data with a short
+                 * packet.  If we are allowed to stall, halt the bulk-in
+                 * endpoint.  (Note: This violates the Bulk-Only Transport
+                 * specification, which requires us to pad the data if we
+                 * don't halt the endpoint.  Presumably nobody will mind.)
+                 */
                 else {
-                        if (mod_data.can_stall) {
-                                bh->inreq->zero = 1;
-                                start_transfer(fsg, fsg->bulk_in, bh->inreq,
-                                                &bh->inreq_busy, &bh->state);
-                                fsg->next_buffhd_to_fill = bh->next;
+                        bh->inreq->zero = 1;
+                        start_transfer(fsg, fsg->bulk_in, bh->inreq,
+                                        &bh->inreq_busy, &bh->state);
+                        fsg->next_buffhd_to_fill = bh->next;
+                        if (mod_data.can_stall)
                                 rc = halt_bulk_in_endpoint(fsg);
-                        } else
-                                rc = pad_with_zeros(fsg);
                 }
                 break;
 
diff --git a/drivers/usb/gadget/fsl_qe_udc.h b/drivers/usb/gadget/fsl_qe_udc.h
index e35e24fd64bb..1da5fb03d218 100644
--- a/drivers/usb/gadget/fsl_qe_udc.h
+++ b/drivers/usb/gadget/fsl_qe_udc.h
@@ -207,7 +207,7 @@ struct qe_frame{
 
 /* Frame status field */
 /* Receive side */
-#define FRAME_OK               0x00000000 /* Frame tranmitted or received OK */
+#define FRAME_OK               0x00000000 /* Frame transmitted or received OK */
 #define FRAME_ERROR            0x80000000 /* Error occurred on frame */
 #define START_FRAME_LOST       0x40000000 /* START_FRAME_LOST */
 #define END_FRAME_LOST         0x20000000 /* END_FRAME_LOST */
diff --git a/drivers/usb/gadget/fsl_udc_core.c b/drivers/usb/gadget/fsl_udc_core.c
index 07499c1cdcc4..2cd9a60c7f3a 100644
--- a/drivers/usb/gadget/fsl_udc_core.c
+++ b/drivers/usb/gadget/fsl_udc_core.c
@@ -1,12 +1,13 @@
 /*
- * Copyright (C) 2004-2007 Freescale Semicondutor, Inc. All rights reserved.
+ * Copyright (C) 2004-2007,2011 Freescale Semiconductor, Inc.
+ * All rights reserved.
  *
  * Author: Li Yang <leoli@freescale.com>
  *         Jiang Bo <tanya.jiang@freescale.com>
  *
  * Description:
  * Freescale high-speed USB SOC DR module device controller driver.
- * This can be found on MPC8349E/MPC8313E cpus.
+ * This can be found on MPC8349E/MPC8313E/MPC5121E cpus.
  * The driver is previously named as mpc_udc.  Based on bare board
  * code from Dave Liu and Shlomi Gridish.
  *
@@ -45,6 +46,7 @@
 #include <asm/system.h>
 #include <asm/unaligned.h>
 #include <asm/dma.h>
+#include <asm/cacheflush.h>
 
 #include "fsl_usb2_udc.h"
 
@@ -77,12 +79,64 @@ fsl_ep0_desc = {
 static void fsl_ep_fifo_flush(struct usb_ep *_ep);
 
 #ifdef CONFIG_PPC32
-#define fsl_readl(addr)         in_le32(addr)
-#define fsl_writel(val32, addr) out_le32(addr, val32)
-#else
+/*
+ * On some SoCs, the USB controller registers can be big or little endian,
+ * depending on the version of the chip. In order to be able to run the
+ * same kernel binary on 2 different versions of an SoC, the BE/LE decision
+ * must be made at run time. _fsl_readl and fsl_writel are pointers to the
+ * BE or LE readl() and writel() functions, and fsl_readl() and fsl_writel()
+ * call through those pointers. Platform code for SoCs that have BE USB
+ * registers should set pdata->big_endian_mmio flag.
+ *
+ * This also applies to controller-to-cpu accessors for the USB descriptors,
+ * since their endianness is also SoC dependant. Platform code for SoCs that
+ * have BE USB descriptors should set pdata->big_endian_desc flag.
+ */
+static u32 _fsl_readl_be(const unsigned __iomem *p)
+{
+        return in_be32(p);
+}
+
+static u32 _fsl_readl_le(const unsigned __iomem *p)
+{
+        return in_le32(p);
+}
+
+static void _fsl_writel_be(u32 v, unsigned __iomem *p)
+{
+        out_be32(p, v);
+}
+
+static void _fsl_writel_le(u32 v, unsigned __iomem *p)
+{
+        out_le32(p, v);
+}
+
+static u32 (*_fsl_readl)(const unsigned __iomem *p);
+static void (*_fsl_writel)(u32 v, unsigned __iomem *p);
+
+#define fsl_readl(p)            (*_fsl_readl)((p))
+#define fsl_writel(v, p)        (*_fsl_writel)((v), (p))
+
+static inline u32 cpu_to_hc32(const u32 x)
+{
+        return udc_controller->pdata->big_endian_desc
+                ? (__force u32)cpu_to_be32(x)
+                : (__force u32)cpu_to_le32(x);
+}
+
+static inline u32 hc32_to_cpu(const u32 x)
+{
+        return udc_controller->pdata->big_endian_desc
+                ? be32_to_cpu((__force __be32)x)
+                : le32_to_cpu((__force __le32)x);
+}
+#else /* !CONFIG_PPC32 */
 #define fsl_readl(addr)         readl(addr)
 #define fsl_writel(val32, addr) writel(val32, addr)
-#endif
+#define cpu_to_hc32(x)          cpu_to_le32(x)
+#define hc32_to_cpu(x)          le32_to_cpu(x)
+#endif /* CONFIG_PPC32 */
 
 /********************************************************************
  *      Internal Used Function
@@ -177,7 +231,8 @@ static void nuke(struct fsl_ep *ep, int status)
 
 static int dr_controller_setup(struct fsl_udc *udc)
 {
-        unsigned int tmp, portctrl;
+        unsigned int tmp, portctrl, ep_num;
+        unsigned int max_no_of_ep;
 #ifndef CONFIG_ARCH_MXC
         unsigned int ctrl;
 #endif
@@ -226,9 +281,12 @@ static int dr_controller_setup(struct fsl_udc *udc)
 
         /* Set the controller as device mode */
         tmp = fsl_readl(&dr_regs->usbmode);
+        tmp &= ~USB_MODE_CTRL_MODE_MASK;        /* clear mode bits */
         tmp |= USB_MODE_CTRL_MODE_DEVICE;
         /* Disable Setup Lockout */
         tmp |= USB_MODE_SETUP_LOCK_OFF;
+        if (udc->pdata->es)
+                tmp |= USB_MODE_ES;
         fsl_writel(tmp, &dr_regs->usbmode);
 
         /* Clear the setup status */
@@ -242,22 +300,34 @@ static int dr_controller_setup(struct fsl_udc *udc)
                 udc->ep_qh, (int)tmp,
                 fsl_readl(&dr_regs->endpointlistaddr));
 
+        max_no_of_ep = (0x0000001F & fsl_readl(&dr_regs->dccparams));
+        for (ep_num = 1; ep_num < max_no_of_ep; ep_num++) {
+                tmp = fsl_readl(&dr_regs->endptctrl[ep_num]);
+                tmp &= ~(EPCTRL_TX_TYPE | EPCTRL_RX_TYPE);
+                tmp |= (EPCTRL_EP_TYPE_BULK << EPCTRL_TX_EP_TYPE_SHIFT)
+                | (EPCTRL_EP_TYPE_BULK << EPCTRL_RX_EP_TYPE_SHIFT);
+                fsl_writel(tmp, &dr_regs->endptctrl[ep_num]);
+        }
         /* Config control enable i/o output, cpu endian register */
 #ifndef CONFIG_ARCH_MXC
-        ctrl = __raw_readl(&usb_sys_regs->control);
-        ctrl |= USB_CTRL_IOENB;
-        __raw_writel(ctrl, &usb_sys_regs->control);
+        if (udc->pdata->have_sysif_regs) {
+                ctrl = __raw_readl(&usb_sys_regs->control);
+                ctrl |= USB_CTRL_IOENB;
+                __raw_writel(ctrl, &usb_sys_regs->control);
+        }
 #endif
 
 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
         /* Turn on cache snooping hardware, since some PowerPC platforms
          * wholly rely on hardware to deal with cache coherent. */
 
-        /* Setup Snooping for all the 4GB space */
-        tmp = SNOOP_SIZE_2GB;   /* starts from 0x0, size 2G */
-        __raw_writel(tmp, &usb_sys_regs->snoop1);
-        tmp |= 0x80000000;      /* starts from 0x8000000, size 2G */
-        __raw_writel(tmp, &usb_sys_regs->snoop2);
+        if (udc->pdata->have_sysif_regs) {
+                /* Setup Snooping for all the 4GB space */
+                tmp = SNOOP_SIZE_2GB;   /* starts from 0x0, size 2G */
+                __raw_writel(tmp, &usb_sys_regs->snoop1);
+                tmp |= 0x80000000;      /* starts from 0x8000000, size 2G */
+                __raw_writel(tmp, &usb_sys_regs->snoop2);
+        }
 #endif
 
         return 0;
@@ -293,6 +363,19 @@ static void dr_controller_stop(struct fsl_udc *udc)
 {
         unsigned int tmp;
 
+        pr_debug("%s\n", __func__);
+
+        /* if we're in OTG mode, and the Host is currently using the port,
+         * stop now and don't rip the controller out from under the
+         * ehci driver
+         */
+        if (udc->gadget.is_otg) {
+                if (!(fsl_readl(&dr_regs->otgsc) & OTGSC_STS_USB_ID)) {
+                        pr_debug("udc: Leaving early\n");
+                        return;
+                }
+        }
+
         /* disable all INTR */
         fsl_writel(0, &dr_regs->usbintr);
 
@@ -318,12 +401,14 @@ static void dr_ep_setup(unsigned char ep_num, unsigned char dir,
                 if (ep_num)
                         tmp_epctrl |= EPCTRL_TX_DATA_TOGGLE_RST;
                 tmp_epctrl |= EPCTRL_TX_ENABLE;
+                tmp_epctrl &= ~EPCTRL_TX_TYPE;
                 tmp_epctrl |= ((unsigned int)(ep_type)
                                 << EPCTRL_TX_EP_TYPE_SHIFT);
         } else {
                 if (ep_num)
                         tmp_epctrl |= EPCTRL_RX_DATA_TOGGLE_RST;
                 tmp_epctrl |= EPCTRL_RX_ENABLE;
+                tmp_epctrl &= ~EPCTRL_RX_TYPE;
                 tmp_epctrl |= ((unsigned int)(ep_type)
                                 << EPCTRL_RX_EP_TYPE_SHIFT);
         }
@@ -409,7 +494,7 @@ static void struct_ep_qh_setup(struct fsl_udc *udc, unsigned char ep_num,
         if (zlt)
                 tmp |= EP_QUEUE_HEAD_ZLT_SEL;
 
-        p_QH->max_pkt_length = cpu_to_le32(tmp);
+        p_QH->max_pkt_length = cpu_to_hc32(tmp);
         p_QH->next_dtd_ptr = 1;
         p_QH->size_ioc_int_sts = 0;
 }
@@ -546,10 +631,13 @@ static int fsl_ep_disable(struct usb_ep *_ep)
         /* disable ep on controller */
         ep_num = ep_index(ep);
         epctrl = fsl_readl(&dr_regs->endptctrl[ep_num]);
-        if (ep_is_in(ep))
-                epctrl &= ~EPCTRL_TX_ENABLE;
-        else
-                epctrl &= ~EPCTRL_RX_ENABLE;
+        if (ep_is_in(ep)) {
+                epctrl &= ~(EPCTRL_TX_ENABLE | EPCTRL_TX_TYPE);
+                epctrl |= EPCTRL_EP_TYPE_BULK << EPCTRL_TX_EP_TYPE_SHIFT;
+        } else {
+                epctrl &= ~(EPCTRL_RX_ENABLE | EPCTRL_TX_TYPE);
+                epctrl |= EPCTRL_EP_TYPE_BULK << EPCTRL_RX_EP_TYPE_SHIFT;
+        }
         fsl_writel(epctrl, &dr_regs->endptctrl[ep_num]);
 
         udc = (struct fsl_udc *)ep->udc;
@@ -616,7 +704,7 @@ static void fsl_queue_td(struct fsl_ep *ep, struct fsl_req *req)
                 struct fsl_req *lastreq;
                 lastreq = list_entry(ep->queue.prev, struct fsl_req, queue);
                 lastreq->tail->next_td_ptr =
-                        cpu_to_le32(req->head->td_dma & DTD_ADDR_MASK);
+                        cpu_to_hc32(req->head->td_dma & DTD_ADDR_MASK);
                 /* Read prime bit, if 1 goto done */
                 if (fsl_readl(&dr_regs->endpointprime) & bitmask)
                         goto out;
@@ -641,10 +729,10 @@ static void fsl_queue_td(struct fsl_ep *ep, struct fsl_req *req)
 
         /* Write dQH next pointer and terminate bit to 0 */
         temp = req->head->td_dma & EP_QUEUE_HEAD_NEXT_POINTER_MASK;
-        dQH->next_dtd_ptr = cpu_to_le32(temp);
+        dQH->next_dtd_ptr = cpu_to_hc32(temp);
 
         /* Clear active and halt bit */
-        temp = cpu_to_le32(~(EP_QUEUE_HEAD_STATUS_ACTIVE
+        temp = cpu_to_hc32(~(EP_QUEUE_HEAD_STATUS_ACTIVE
                         | EP_QUEUE_HEAD_STATUS_HALT));
         dQH->size_ioc_int_sts &= temp;
 
@@ -682,17 +770,17 @@ static struct ep_td_struct *fsl_build_dtd(struct fsl_req *req, unsigned *length,
 
         dtd->td_dma = *dma;
         /* Clear reserved field */
-        swap_temp = cpu_to_le32(dtd->size_ioc_sts);
+        swap_temp = hc32_to_cpu(dtd->size_ioc_sts);
         swap_temp &= ~DTD_RESERVED_FIELDS;
-        dtd->size_ioc_sts = cpu_to_le32(swap_temp);
+        dtd->size_ioc_sts = cpu_to_hc32(swap_temp);
 
         /* Init all of buffer page pointers */
         swap_temp = (u32) (req->req.dma + req->req.actual);
-        dtd->buff_ptr0 = cpu_to_le32(swap_temp);
-        dtd->buff_ptr1 = cpu_to_le32(swap_temp + 0x1000);
-        dtd->buff_ptr2 = cpu_to_le32(swap_temp + 0x2000);
-        dtd->buff_ptr3 = cpu_to_le32(swap_temp + 0x3000);
-        dtd->buff_ptr4 = cpu_to_le32(swap_temp + 0x4000);
+        dtd->buff_ptr0 = cpu_to_hc32(swap_temp);
+        dtd->buff_ptr1 = cpu_to_hc32(swap_temp + 0x1000);
+        dtd->buff_ptr2 = cpu_to_hc32(swap_temp + 0x2000);
+        dtd->buff_ptr3 = cpu_to_hc32(swap_temp + 0x3000);
+        dtd->buff_ptr4 = cpu_to_hc32(swap_temp + 0x4000);
 
         req->req.actual += *length;
 
@@ -716,7 +804,7 @@ static struct ep_td_struct *fsl_build_dtd(struct fsl_req *req, unsigned *length,
         if (*is_last && !req->req.no_interrupt)
                 swap_temp |= DTD_IOC;
 
-        dtd->size_ioc_sts = cpu_to_le32(swap_temp);
+        dtd->size_ioc_sts = cpu_to_hc32(swap_temp);
 
         mb();
 
@@ -743,7 +831,7 @@ static int fsl_req_to_dtd(struct fsl_req *req)
                         is_first = 0;
                         req->head = dtd;
                 } else {
-                        last_dtd->next_td_ptr = cpu_to_le32(dma);
+                        last_dtd->next_td_ptr = cpu_to_hc32(dma);
                         last_dtd->next_td_virt = dtd;
                 }
                 last_dtd = dtd;
@@ -751,7 +839,7 @@ static int fsl_req_to_dtd(struct fsl_req *req)
                 req->dtd_count++;
         } while (!is_last);
 
-        dtd->next_td_ptr = cpu_to_le32(DTD_NEXT_TERMINATE);
+        dtd->next_td_ptr = cpu_to_hc32(DTD_NEXT_TERMINATE);
 
         req->tail = dtd;
 
@@ -962,6 +1050,36 @@ out:
         return status;
 }
 
+static int fsl_ep_fifo_status(struct usb_ep *_ep)
+{
+        struct fsl_ep *ep;
+        struct fsl_udc *udc;
+        int size = 0;
+        u32 bitmask;
+        struct ep_queue_head *d_qh;
+
+        ep = container_of(_ep, struct fsl_ep, ep);
+        if (!_ep || (!ep->desc && ep_index(ep) != 0))
+                return -ENODEV;
+
+        udc = (struct fsl_udc *)ep->udc;
+
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        d_qh = &ep->udc->ep_qh[ep_index(ep) * 2 + ep_is_in(ep)];
+
+        bitmask = (ep_is_in(ep)) ? (1 << (ep_index(ep) + 16)) :
+            (1 << (ep_index(ep)));
+
+        if (fsl_readl(&dr_regs->endptstatus) & bitmask)
+                size = (d_qh->size_ioc_int_sts & DTD_PACKET_SIZE)
+                    >> DTD_LENGTH_BIT_POS;
+
+        pr_debug("%s %u\n", __func__, size);
+        return size;
+}
+
 static void fsl_ep_fifo_flush(struct usb_ep *_ep)
 {
         struct fsl_ep *ep;
@@ -1014,6 +1132,7 @@ static struct usb_ep_ops fsl_ep_ops = {
         .dequeue = fsl_ep_dequeue,
 
         .set_halt = fsl_ep_set_halt,
+        .fifo_status = fsl_ep_fifo_status,
         .fifo_flush = fsl_ep_fifo_flush,        /* flush fifo */
 };
 
@@ -1228,6 +1347,10 @@ static void ch9getstatus(struct fsl_udc *udc, u8 request_type, u16 value,
         req = udc->status_req;
         /* Fill in the reqest structure */
         *((u16 *) req->req.buf) = cpu_to_le16(tmp);
+
+        /* flush cache for the req buffer */
+        flush_dcache_range((u32)req->req.buf, (u32)req->req.buf + 8);
+
         req->ep = ep;
         req->req.length = 2;
         req->req.status = -EINPROGRESS;
@@ -1280,6 +1403,7 @@ static void setup_received_irq(struct fsl_udc *udc,
                 /* Status phase from udc */
         {
                 int rc = -EOPNOTSUPP;
+                u16 ptc = 0;
 
                 if ((setup->bRequestType & (USB_RECIP_MASK | USB_TYPE_MASK))
                                 == (USB_RECIP_ENDPOINT | USB_TYPE_STANDARD)) {
@@ -1301,17 +1425,19 @@ static void setup_received_irq(struct fsl_udc *udc,
                                 | USB_TYPE_STANDARD)) {
                         /* Note: The driver has not include OTG support yet.
                          * This will be set when OTG support is added */
-                        if (!gadget_is_otg(&udc->gadget))
-                                break;
-                        else if (setup->bRequest == USB_DEVICE_B_HNP_ENABLE)
-                                udc->gadget.b_hnp_enable = 1;
-                        else if (setup->bRequest == USB_DEVICE_A_HNP_SUPPORT)
-                                udc->gadget.a_hnp_support = 1;
-                        else if (setup->bRequest ==
-                                        USB_DEVICE_A_ALT_HNP_SUPPORT)
-                                udc->gadget.a_alt_hnp_support = 1;
-                        else
-                                break;
+                        if (wValue == USB_DEVICE_TEST_MODE)
+                                ptc = wIndex >> 8;
+                        else if (gadget_is_otg(&udc->gadget)) {
+                                if (setup->bRequest ==
+                                    USB_DEVICE_B_HNP_ENABLE)
+                                        udc->gadget.b_hnp_enable = 1;
+                                else if (setup->bRequest ==
+                                         USB_DEVICE_A_HNP_SUPPORT)
+                                        udc->gadget.a_hnp_support = 1;
+                                else if (setup->bRequest ==
+                                         USB_DEVICE_A_ALT_HNP_SUPPORT)
+                                        udc->gadget.a_alt_hnp_support = 1;
+                        }
                         rc = 0;
                 } else
                         break;
@@ -1320,6 +1446,15 @@ static void setup_received_irq(struct fsl_udc *udc,
                         if (ep0_prime_status(udc, EP_DIR_IN))
                                 ep0stall(udc);
                 }
+                if (ptc) {
+                        u32 tmp;
+
+                        mdelay(10);
+                        tmp = fsl_readl(&dr_regs->portsc1) | (ptc << 16);
+                        fsl_writel(tmp, &dr_regs->portsc1);
+                        printk(KERN_INFO "udc: switch to test mode %d.\n", ptc);
+                }
+
                 return;
         }
 
@@ -1394,6 +1529,7 @@ static void tripwire_handler(struct fsl_udc *udc, u8 ep_num, u8 *buffer_ptr)
 {
         u32 temp;
         struct ep_queue_head *qh;
+        struct fsl_usb2_platform_data *pdata = udc->pdata;
 
         qh = &udc->ep_qh[ep_num * 2 + EP_DIR_OUT];
 
@@ -1408,7 +1544,16 @@ static void tripwire_handler(struct fsl_udc *udc, u8 ep_num, u8 *buffer_ptr)
                 fsl_writel(temp | USB_CMD_SUTW, &dr_regs->usbcmd);
 
                 /* Copy the setup packet to local buffer */
-                memcpy(buffer_ptr, (u8 *) qh->setup_buffer, 8);
+                if (pdata->le_setup_buf) {
+                        u32 *p = (u32 *)buffer_ptr;
+                        u32 *s = (u32 *)qh->setup_buffer;
+
+                        /* Convert little endian setup buffer to CPU endian */
+                        *p++ = le32_to_cpu(*s++);
+                        *p = le32_to_cpu(*s);
+                } else {
+                        memcpy(buffer_ptr, (u8 *) qh->setup_buffer, 8);
+                }
         } while (!(fsl_readl(&dr_regs->usbcmd) & USB_CMD_SUTW));
 
         /* Clear Setup Tripwire */
@@ -1432,19 +1577,19 @@ static int process_ep_req(struct fsl_udc *udc, int pipe,
         actual = curr_req->req.length;
 
         for (j = 0; j < curr_req->dtd_count; j++) {
-                remaining_length = (le32_to_cpu(curr_td->size_ioc_sts)
+                remaining_length = (hc32_to_cpu(curr_td->size_ioc_sts)
                                         & DTD_PACKET_SIZE)
                                 >> DTD_LENGTH_BIT_POS;
                 actual -= remaining_length;
 
-                if ((errors = le32_to_cpu(curr_td->size_ioc_sts) &
-                                                DTD_ERROR_MASK)) {
+                errors = hc32_to_cpu(curr_td->size_ioc_sts);
+                if (errors & DTD_ERROR_MASK) {
                         if (errors & DTD_STATUS_HALTED) {
                                 ERR("dTD error %08x QH=%d\n", errors, pipe);
                                 /* Clear the errors and Halt condition */
-                                tmp = le32_to_cpu(curr_qh->size_ioc_int_sts);
+                                tmp = hc32_to_cpu(curr_qh->size_ioc_int_sts);
                                 tmp &= ~errors;
-                                curr_qh->size_ioc_int_sts = cpu_to_le32(tmp);
+                                curr_qh->size_ioc_int_sts = cpu_to_hc32(tmp);
                                 status = -EPIPE;
                                 /* FIXME: continue with next queued TD? */
 
@@ -1462,7 +1607,7 @@ static int process_ep_req(struct fsl_udc *udc, int pipe,
                                 ERR("Unknown error has occurred (0x%x)!\n",
                                         errors);
 
-                } else if (le32_to_cpu(curr_td->size_ioc_sts)
+                } else if (hc32_to_cpu(curr_td->size_ioc_sts)
                                 & DTD_STATUS_ACTIVE) {
                         VDBG("Request not complete");
                         status = REQ_UNCOMPLETE;
@@ -1551,6 +1696,9 @@ static void port_change_irq(struct fsl_udc *udc)
 {
         u32 speed;
 
+        if (udc->bus_reset)
+                udc->bus_reset = 0;
+
         /* Bus resetting is finished */
         if (!(fsl_readl(&dr_regs->portsc1) & PORTSCX_PORT_RESET)) {
                 /* Get the speed */
@@ -1658,6 +1806,8 @@ static void reset_irq(struct fsl_udc *udc)
 
         if (fsl_readl(&dr_regs->portsc1) & PORTSCX_PORT_RESET) {
                 VDBG("Bus reset");
+                /* Bus is reseting */
+                udc->bus_reset = 1;
                 /* Reset all the queues, include XD, dTD, EP queue
                  * head and TR Queue */
                 reset_queues(udc);
@@ -1735,6 +1885,7 @@ static irqreturn_t fsl_udc_irq(int irq, void *_udc)
 
         /* Reset Received */
         if (irq_src & USB_STS_RESET) {
+                VDBG("reset int");
                 reset_irq(udc);
                 status = IRQ_HANDLED;
         }
@@ -1792,11 +1943,30 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
                 goto out;
         }
 
-        /* Enable DR IRQ reg and Set usbcmd reg  Run bit */
-        dr_controller_run(udc_controller);
-        udc_controller->usb_state = USB_STATE_ATTACHED;
-        udc_controller->ep0_state = WAIT_FOR_SETUP;
-        udc_controller->ep0_dir = 0;
+        if (udc_controller->transceiver) {
+                /* Suspend the controller until OTG enable it */
+                udc_controller->stopped = 1;
+                printk(KERN_INFO "Suspend udc for OTG auto detect\n");
+
+                /* connect to bus through transceiver */
+                if (udc_controller->transceiver) {
+                        retval = otg_set_peripheral(udc_controller->transceiver,
+                                                    &udc_controller->gadget);
+                        if (retval < 0) {
+                                ERR("can't bind to transceiver\n");
+                                driver->unbind(&udc_controller->gadget);
+                                udc_controller->gadget.dev.driver = 0;
+                                udc_controller->driver = 0;
+                                return retval;
+                        }
+                }
+        } else {
+                /* Enable DR IRQ reg and set USBCMD reg Run bit */
+                dr_controller_run(udc_controller);
+                udc_controller->usb_state = USB_STATE_ATTACHED;
+                udc_controller->ep0_state = WAIT_FOR_SETUP;
+                udc_controller->ep0_dir = 0;
+        }
         printk(KERN_INFO "%s: bind to driver %s\n",
                         udc_controller->gadget.name, driver->driver.name);
 
@@ -2044,16 +2214,18 @@ static int fsl_proc_read(char *page, char **start, off_t off, int count,
         next += t;
 
 #ifndef CONFIG_ARCH_MXC
-        tmp_reg = usb_sys_regs->snoop1;
-        t = scnprintf(next, size, "Snoop1 Reg : = [0x%x]\n\n", tmp_reg);
-        size -= t;
-        next += t;
+        if (udc->pdata->have_sysif_regs) {
+                tmp_reg = usb_sys_regs->snoop1;
+                t = scnprintf(next, size, "Snoop1 Reg : = [0x%x]\n\n", tmp_reg);
+                size -= t;
+                next += t;
 
-        tmp_reg = usb_sys_regs->control;
-        t = scnprintf(next, size, "General Control Reg : = [0x%x]\n\n",
-                        tmp_reg);
-        size -= t;
-        next += t;
+                tmp_reg = usb_sys_regs->control;
+                t = scnprintf(next, size, "General Control Reg : = [0x%x]\n\n",
+                                tmp_reg);
+                size -= t;
+                next += t;
+        }
 #endif
 
         /* ------fsl_udc, fsl_ep, fsl_request structure information ----- */
@@ -2233,6 +2405,7 @@ static int __init struct_ep_setup(struct fsl_udc *udc, unsigned char index,
  */
 static int __init fsl_udc_probe(struct platform_device *pdev)
 {
+        struct fsl_usb2_platform_data *pdata;
         struct resource *res;
         int ret = -ENODEV;
         unsigned int i;
@@ -2249,20 +2422,35 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        pdata = pdev->dev.platform_data;
+        udc_controller->pdata = pdata;
         spin_lock_init(&udc_controller->lock);
         udc_controller->stopped = 1;
 
+#ifdef CONFIG_USB_OTG
+        if (pdata->operating_mode == FSL_USB2_DR_OTG) {
+                udc_controller->transceiver = otg_get_transceiver();
+                if (!udc_controller->transceiver) {
+                        ERR("Can't find OTG driver!\n");
+                        ret = -ENODEV;
+                        goto err_kfree;
+                }
+        }
+#endif
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 ret = -ENXIO;
                 goto err_kfree;
         }
 
-        if (!request_mem_region(res->start, res->end - res->start + 1,
-                                driver_name)) {
-                ERR("request mem region for %s failed\n", pdev->name);
-                ret = -EBUSY;
-                goto err_kfree;
+        if (pdata->operating_mode == FSL_USB2_DR_DEVICE) {
+                if (!request_mem_region(res->start, res->end - res->start + 1,
+                                        driver_name)) {
+                        ERR("request mem region for %s failed\n", pdev->name);
+                        ret = -EBUSY;
+                        goto err_kfree;
+                }
         }
 
         dr_regs = ioremap(res->start, resource_size(res));
@@ -2271,9 +2459,29 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
                 goto err_release_mem_region;
         }
 
+        pdata->regs = (void *)dr_regs;
+
+        /*
+         * do platform specific init: check the clock, grab/config pins, etc.
+         */
+        if (pdata->init && pdata->init(pdev)) {
+                ret = -ENODEV;
+                goto err_iounmap_noclk;
+        }
+
+        /* Set accessors only after pdata->init() ! */
+        if (pdata->big_endian_mmio) {
+                _fsl_readl = _fsl_readl_be;
+                _fsl_writel = _fsl_writel_be;
+        } else {
+                _fsl_readl = _fsl_readl_le;
+                _fsl_writel = _fsl_writel_le;
+        }
+
 #ifndef CONFIG_ARCH_MXC
-        usb_sys_regs = (struct usb_sys_interface *)
-                        ((u32)dr_regs + USB_DR_SYS_OFFSET);
+        if (pdata->have_sysif_regs)
+                usb_sys_regs = (struct usb_sys_interface *)
+                                ((u32)dr_regs + USB_DR_SYS_OFFSET);
 #endif
 
         /* Initialize USB clocks */
@@ -2313,9 +2521,11 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
                 goto err_free_irq;
         }
 
-        /* initialize usb hw reg except for regs for EP,
-         * leave usbintr reg untouched */
-        dr_controller_setup(udc_controller);
+        if (!udc_controller->transceiver) {
+                /* initialize usb hw reg except for regs for EP,
+                 * leave usbintr reg untouched */
+                dr_controller_setup(udc_controller);
+        }
 
         fsl_udc_clk_finalize(pdev);
 
@@ -2335,6 +2545,9 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto err_free_irq;
 
+        if (udc_controller->transceiver)
+                udc_controller->gadget.is_otg = 1;
+
         /* setup QH and epctrl for ep0 */
         ep0_setup(udc_controller);
 
@@ -2373,11 +2586,14 @@ err_unregister:
 err_free_irq:
         free_irq(udc_controller->irq, udc_controller);
 err_iounmap:
+        if (pdata->exit)
+                pdata->exit(pdev);
         fsl_udc_clk_release();
 err_iounmap_noclk:
         iounmap(dr_regs);
 err_release_mem_region:
-        release_mem_region(res->start, res->end - res->start + 1);
+        if (pdata->operating_mode == FSL_USB2_DR_DEVICE)
+                release_mem_region(res->start, res->end - res->start + 1);
 err_kfree:
         kfree(udc_controller);
         udc_controller = NULL;
@@ -2390,6 +2606,7 @@ err_kfree:
 static int __exit fsl_udc_remove(struct platform_device *pdev)
 {
         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
 
         DECLARE_COMPLETION(done);
 
@@ -2410,12 +2627,20 @@ static int __exit fsl_udc_remove(struct platform_device *pdev)
         dma_pool_destroy(udc_controller->td_pool);
         free_irq(udc_controller->irq, udc_controller);
         iounmap(dr_regs);
-        release_mem_region(res->start, res->end - res->start + 1);
+        if (pdata->operating_mode == FSL_USB2_DR_DEVICE)
+                release_mem_region(res->start, res->end - res->start + 1);
 
         device_unregister(&udc_controller->gadget.dev);
         /* free udc --wait for the release() finished */
         wait_for_completion(&done);
 
+        /*
+         * do platform specific un-initialization:
+         * release iomux pins, etc.
+         */
+        if (pdata->exit)
+                pdata->exit(pdev);
+
         return 0;
 }
 
@@ -2446,6 +2671,62 @@ static int fsl_udc_resume(struct platform_device *pdev)
         return 0;
 }
 
+static int fsl_udc_otg_suspend(struct device *dev, pm_message_t state)
+{
+        struct fsl_udc *udc = udc_controller;
+        u32 mode, usbcmd;
+
+        mode = fsl_readl(&dr_regs->usbmode) & USB_MODE_CTRL_MODE_MASK;
+
+        pr_debug("%s(): mode 0x%x stopped %d\n", __func__, mode, udc->stopped);
+
+        /*
+         * If the controller is already stopped, then this must be a
+         * PM suspend.  Remember this fact, so that we will leave the
+         * controller stopped at PM resume time.
+         */
+        if (udc->stopped) {
+                pr_debug("gadget already stopped, leaving early\n");
+                udc->already_stopped = 1;
+                return 0;
+        }
+
+        if (mode != USB_MODE_CTRL_MODE_DEVICE) {
+                pr_debug("gadget not in device mode, leaving early\n");
+                return 0;
+        }
+
+        /* stop the controller */
+        usbcmd = fsl_readl(&dr_regs->usbcmd) & ~USB_CMD_RUN_STOP;
+        fsl_writel(usbcmd, &dr_regs->usbcmd);
+
+        udc->stopped = 1;
+
+        pr_info("USB Gadget suspended\n");
+
+        return 0;
+}
+
+static int fsl_udc_otg_resume(struct device *dev)
+{
+        pr_debug("%s(): stopped %d  already_stopped %d\n", __func__,
+                 udc_controller->stopped, udc_controller->already_stopped);
+
+        /*
+         * If the controller was stopped at suspend time, then
+         * don't resume it now.
+         */
+        if (udc_controller->already_stopped) {
+                udc_controller->already_stopped = 0;
+                pr_debug("gadget was already stopped, leaving early\n");
+                return 0;
+        }
+
+        pr_info("USB Gadget resume\n");
+
+        return fsl_udc_resume(NULL);
+}
+
 /*-------------------------------------------------------------------------
         Register entry point for the peripheral controller driver
 --------------------------------------------------------------------------*/
@@ -2458,6 +2739,9 @@ static struct platform_driver udc_driver = {
         .driver  = {
                 .name = (char *)driver_name,
                 .owner = THIS_MODULE,
+                /* udc suspend/resume called from OTG driver */
+                .suspend = fsl_udc_otg_suspend,
+                .resume  = fsl_udc_otg_resume,
         },
 };
 
diff --git a/drivers/usb/gadget/fsl_usb2_udc.h b/drivers/usb/gadget/fsl_usb2_udc.h
index e88cce5c2c0d..1d51be83fda8 100644
--- a/drivers/usb/gadget/fsl_usb2_udc.h
+++ b/drivers/usb/gadget/fsl_usb2_udc.h
@@ -275,7 +275,9 @@ struct usb_sys_interface {
 #define  USB_MODE_CTRL_MODE_IDLE              0x00000000
 #define  USB_MODE_CTRL_MODE_DEVICE            0x00000002
 #define  USB_MODE_CTRL_MODE_HOST              0x00000003
+#define  USB_MODE_CTRL_MODE_MASK              0x00000003
 #define  USB_MODE_CTRL_MODE_RSV               0x00000001
+#define  USB_MODE_ES                          0x00000004 /* Endian Select */
 #define  USB_MODE_SETUP_LOCK_OFF              0x00000008
 #define  USB_MODE_STREAM_DISABLE              0x00000010
 /* Endpoint Flush Register */
@@ -461,6 +463,7 @@ struct fsl_ep {
 struct fsl_udc {
         struct usb_gadget gadget;
         struct usb_gadget_driver *driver;
+        struct fsl_usb2_platform_data *pdata;
         struct completion *done;        /* to make sure release() is done */
         struct fsl_ep *eps;
         unsigned int max_ep;
@@ -473,6 +476,8 @@ struct fsl_udc {
         unsigned vbus_active:1;
         unsigned stopped:1;
         unsigned remote_wakeup:1;
+        unsigned already_stopped:1;
+        unsigned big_endian_desc:1;
 
         struct ep_queue_head *ep_qh;    /* Endpoints Queue-Head */
         struct fsl_req *status_req;     /* ep0 status request */
@@ -483,6 +488,7 @@ struct fsl_udc {
         dma_addr_t ep_qh_dma;           /* dma address of QH */
 
         u32 max_pipes;          /* Device max pipes */
+        u32 bus_reset;          /* Device is bus resetting */
         u32 resume_state;       /* USB state to resume */
         u32 usb_state;          /* USB current state */
         u32 ep0_state;          /* Endpoint zero state */
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index e896f6359dfe..ec3fd979c71d 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -148,6 +148,12 @@
 #define gadget_is_ci13xxx_msm(g)        0
 #endif
 
+#ifdef CONFIG_USB_GADGET_RENESAS_USBHS
+#define gadget_is_renesas_usbhs(g) (!strcmp("renesas_usbhs_udc", (g)->name))
+#else
+#define gadget_is_renesas_usbhs(g) 0
+#endif
+
 /**
  * usb_gadget_controller_number - support bcdDevice id convention
  * @gadget: the controller being driven
@@ -207,6 +213,9 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x27;
         else if (gadget_is_ci13xxx_msm(gadget))
                 return 0x28;
+        else if (gadget_is_renesas_usbhs(gadget))
+                return 0x29;
+
         return -ENOENT;
 }
 
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index c3f2bd42bd5a..271ef94668e7 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -1189,6 +1189,8 @@ printer_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         else if (gadget->a_alt_hnp_support)
                                 DBG(dev, "HNP needs a different root port\n");
                         value = printer_set_config(dev, wValue);
+                        if (!value)
+                                value = set_interface(dev, PRINTER_INTERFACE);
                         break;
                 case USB_REQ_GET_CONFIGURATION:
                         if (ctrl->bRequestType != USB_DIR_IN)
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c
index 0912679de99a..baf96ce16b6a 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/gadget/s3c-hsotg.c
@@ -1,5 +1,8 @@
 /* linux/drivers/usb/gadget/s3c-hsotg.c
  *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
  * Copyright 2008 Openmoko, Inc.
  * Copyright 2008 Simtec Electronics
  *      Ben Dooks <ben@simtec.co.uk>
@@ -679,6 +682,14 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
                 __func__, readl(hsotg->regs + epctrl_reg), index,
                 hs_ep->dir_in ? "in" : "out");
 
+        /* If endpoint is stalled, we will restart request later */
+        ctrl = readl(hsotg->regs + epctrl_reg);
+
+        if (ctrl & S3C_DxEPCTL_Stall) {
+                dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index);
+                return;
+        }
+
         length = ureq->length - ureq->actual;
 
         if (0)
@@ -731,18 +742,6 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
         /* write size / packets */
         writel(epsize, hsotg->regs + epsize_reg);
 
-        ctrl = readl(hsotg->regs + epctrl_reg);
-
-        if (ctrl & S3C_DxEPCTL_Stall) {
-                dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index);
-
-                /* not sure what we can do here, if it is EP0 then we should
-                 * get this cleared once the endpoint has transmitted the
-                 * STALL packet, otherwise it needs to be cleared by the
-                 * host.
-                 */
-        }
-
         if (using_dma(hsotg)) {
                 unsigned int dma_reg;
 
@@ -1048,6 +1047,20 @@ static int s3c_hsotg_process_req_status(struct s3c_hsotg *hsotg,
 static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value);
 
 /**
+ * get_ep_head - return the first request on the endpoint
+ * @hs_ep: The controller endpoint to get
+ *
+ * Get the first request on the endpoint.
+ */
+static struct s3c_hsotg_req *get_ep_head(struct s3c_hsotg_ep *hs_ep)
+{
+        if (list_empty(&hs_ep->queue))
+                return NULL;
+
+        return list_first_entry(&hs_ep->queue, struct s3c_hsotg_req, queue);
+}
+
+/**
  * s3c_hsotg_process_req_featire - process request {SET,CLEAR}_FEATURE
  * @hsotg: The device state
  * @ctrl: USB control request
@@ -1055,8 +1068,12 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value);
 static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
                                          struct usb_ctrlrequest *ctrl)
 {
+        struct s3c_hsotg_ep *ep0 = &hsotg->eps[0];
+        struct s3c_hsotg_req *hs_req;
+        bool restart;
         bool set = (ctrl->bRequest == USB_REQ_SET_FEATURE);
         struct s3c_hsotg_ep *ep;
+        int ret;
 
         dev_dbg(hsotg->dev, "%s: %s_FEATURE\n",
                 __func__, set ? "SET" : "CLEAR");
@@ -1072,6 +1089,36 @@ static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
                 switch (le16_to_cpu(ctrl->wValue)) {
                 case USB_ENDPOINT_HALT:
                         s3c_hsotg_ep_sethalt(&ep->ep, set);
+
+                        ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
+                        if (ret) {
+                                dev_err(hsotg->dev,
+                                        "%s: failed to send reply\n", __func__);
+                                return ret;
+                        }
+
+                        if (!set) {
+                                /*
+                                 * If we have request in progress,
+                                 * then complete it
+                                 */
+                                if (ep->req) {
+                                        hs_req = ep->req;
+                                        ep->req = NULL;
+                                        list_del_init(&hs_req->queue);
+                                        hs_req->req.complete(&ep->ep,
+                                                             &hs_req->req);
+                                }
+
+                                /* If we have pending request, then start it */
+                                restart = !list_empty(&ep->queue);
+                                if (restart) {
+                                        hs_req = get_ep_head(ep);
+                                        s3c_hsotg_start_req(hsotg, ep,
+                                                            hs_req, false);
+                                }
+                        }
+
                         break;
 
                 default:
@@ -1148,14 +1195,6 @@ static void s3c_hsotg_process_control(struct s3c_hsotg *hsotg,
                         dev_dbg(hsotg->dev, "driver->setup() ret %d\n", ret);
         }
 
-        if (ret > 0) {
-                if (!ep0->dir_in) {
-                        /* need to generate zlp in reply or take data */
-                        /* todo - deal with any data we might be sent? */
-                        ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
-                }
-        }
-
         /* the request is either unhandlable, or is not formatted correctly
          * so respond with a STALL for the status stage to indicate failure.
          */
@@ -1247,20 +1286,6 @@ static void s3c_hsotg_enqueue_setup(struct s3c_hsotg *hsotg)
 }
 
 /**
- * get_ep_head - return the first request on the endpoint
- * @hs_ep: The controller endpoint to get
- *
- * Get the first request on the endpoint.
-*/
-static struct s3c_hsotg_req *get_ep_head(struct s3c_hsotg_ep *hs_ep)
-{
-        if (list_empty(&hs_ep->queue))
-                return NULL;
-
-        return list_first_entry(&hs_ep->queue, struct s3c_hsotg_req, queue);
-}
-
-/**
  * s3c_hsotg_complete_request - complete a request given to us
  * @hsotg: The device state.
  * @hs_ep: The endpoint the request was on.
@@ -1683,6 +1708,37 @@ bad_mps:
         dev_err(hsotg->dev, "ep%d: bad mps of %d\n", ep, mps);
 }
 
+/**
+ * s3c_hsotg_txfifo_flush - flush Tx FIFO
+ * @hsotg: The driver state
+ * @idx: The index for the endpoint (0..15)
+ */
+static void s3c_hsotg_txfifo_flush(struct s3c_hsotg *hsotg, unsigned int idx)
+{
+        int timeout;
+        int val;
+
+        writel(S3C_GRSTCTL_TxFNum(idx) | S3C_GRSTCTL_TxFFlsh,
+                hsotg->regs + S3C_GRSTCTL);
+
+        /* wait until the fifo is flushed */
+        timeout = 100;
+
+        while (1) {
+                val = readl(hsotg->regs + S3C_GRSTCTL);
+
+                if ((val & (S3C_GRSTCTL_TxFFlsh)) == 0)
+                        break;
+
+                if (--timeout == 0) {
+                        dev_err(hsotg->dev,
+                                "%s: timeout flushing fifo (GRSTCTL=%08x)\n",
+                                __func__, val);
+                }
+
+                udelay(1);
+        }
+}
 
 /**
  * s3c_hsotg_trytx - check to see if anything needs transmitting
@@ -1775,10 +1831,12 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
         u32 epctl_reg = dir_in ? S3C_DIEPCTL(idx) : S3C_DOEPCTL(idx);
         u32 epsiz_reg = dir_in ? S3C_DIEPTSIZ(idx) : S3C_DOEPTSIZ(idx);
         u32 ints;
-        u32 clear = 0;
 
         ints = readl(hsotg->regs + epint_reg);
 
+        /* Clear endpoint interrupts */
+        writel(ints, hsotg->regs + epint_reg);
+
         dev_dbg(hsotg->dev, "%s: ep%d(%s) DxEPINT=0x%08x\n",
                 __func__, idx, dir_in ? "in" : "out", ints);
 
@@ -1801,19 +1859,28 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
 
                         s3c_hsotg_handle_outdone(hsotg, idx, false);
                 }
-
-                clear |= S3C_DxEPINT_XferCompl;
         }
 
         if (ints & S3C_DxEPINT_EPDisbld) {
                 dev_dbg(hsotg->dev, "%s: EPDisbld\n", __func__);
-                clear |= S3C_DxEPINT_EPDisbld;
+
+                if (dir_in) {
+                        int epctl = readl(hsotg->regs + epctl_reg);
+
+                        s3c_hsotg_txfifo_flush(hsotg, idx);
+
+                        if ((epctl & S3C_DxEPCTL_Stall) &&
+                                (epctl & S3C_DxEPCTL_EPType_Bulk)) {
+                                int dctl = readl(hsotg->regs + S3C_DCTL);
+
+                                dctl |= S3C_DCTL_CGNPInNAK;
+                                writel(dctl, hsotg->regs + S3C_DCTL);
+                        }
+                }
         }
 
-        if (ints & S3C_DxEPINT_AHBErr) {
+        if (ints & S3C_DxEPINT_AHBErr)
                 dev_dbg(hsotg->dev, "%s: AHBErr\n", __func__);
-                clear |= S3C_DxEPINT_AHBErr;
-        }
 
         if (ints & S3C_DxEPINT_Setup) {  /* Setup or Timeout */
                 dev_dbg(hsotg->dev, "%s: Setup/Timeout\n",  __func__);
@@ -1829,14 +1896,10 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                         else
                                 s3c_hsotg_handle_outdone(hsotg, 0, true);
                 }
-
-                clear |= S3C_DxEPINT_Setup;
         }
 
-        if (ints & S3C_DxEPINT_Back2BackSetup) {
+        if (ints & S3C_DxEPINT_Back2BackSetup)
                 dev_dbg(hsotg->dev, "%s: B2BSetup/INEPNakEff\n", __func__);
-                clear |= S3C_DxEPINT_Back2BackSetup;
-        }
 
         if (dir_in) {
                 /* not sure if this is important, but we'll clear it anyway
@@ -1844,14 +1907,12 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                 if (ints & S3C_DIEPMSK_INTknTXFEmpMsk) {
                         dev_dbg(hsotg->dev, "%s: ep%d: INTknTXFEmpMsk\n",
                                 __func__, idx);
-                        clear |= S3C_DIEPMSK_INTknTXFEmpMsk;
                 }
 
                 /* this probably means something bad is happening */
                 if (ints & S3C_DIEPMSK_INTknEPMisMsk) {
                         dev_warn(hsotg->dev, "%s: ep%d: INTknEP\n",
                                  __func__, idx);
-                        clear |= S3C_DIEPMSK_INTknEPMisMsk;
                 }
 
                 /* FIFO has space or is empty (see GAHBCFG) */
@@ -1860,11 +1921,8 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                         dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n",
                                 __func__, idx);
                         s3c_hsotg_trytx(hsotg, hs_ep);
-                        clear |= S3C_DIEPMSK_TxFIFOEmpty;
                 }
         }
-
-        writel(clear, hsotg->regs + epint_reg);
 }
 
 /**
@@ -2056,7 +2114,6 @@ irq_retry:
                 dev_info(hsotg->dev, "OTGInt: %08x\n", otgint);
 
                 writel(otgint, hsotg->regs + S3C_GOTGINT);
-                writel(S3C_GINTSTS_OTGInt, hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_DisconnInt) {
@@ -2072,8 +2129,9 @@ irq_retry:
         }
 
         if (gintsts & S3C_GINTSTS_EnumDone) {
-                s3c_hsotg_irq_enumdone(hsotg);
                 writel(S3C_GINTSTS_EnumDone, hsotg->regs + S3C_GINTSTS);
+
+                s3c_hsotg_irq_enumdone(hsotg);
         }
 
         if (gintsts & S3C_GINTSTS_ConIDStsChng) {
@@ -2101,10 +2159,6 @@ irq_retry:
                         if (daint_in & 1)
                                 s3c_hsotg_epint(hsotg, ep, 1);
                 }
-
-                writel(daint, hsotg->regs + S3C_DAINT);
-                writel(gintsts & (S3C_GINTSTS_OEPInt | S3C_GINTSTS_IEPInt),
-                       hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_USBRst) {
@@ -2112,6 +2166,8 @@ irq_retry:
                 dev_dbg(hsotg->dev, "GNPTXSTS=%08x\n",
                         readl(hsotg->regs + S3C_GNPTXSTS));
 
+                writel(S3C_GINTSTS_USBRst, hsotg->regs + S3C_GINTSTS);
+
                 kill_all_requests(hsotg, &hsotg->eps[0], -ECONNRESET, true);
 
                 /* it seems after a reset we can end up with a situation
@@ -2123,8 +2179,6 @@ irq_retry:
                 s3c_hsotg_init_fifo(hsotg);
 
                 s3c_hsotg_enqueue_setup(hsotg);
-
-                writel(S3C_GINTSTS_USBRst, hsotg->regs + S3C_GINTSTS);
         }
 
         /* check both FIFOs */
@@ -2138,8 +2192,6 @@ irq_retry:
 
                 s3c_hsotg_disable_gsint(hsotg, S3C_GINTSTS_NPTxFEmp);
                 s3c_hsotg_irq_fifoempty(hsotg, false);
-
-                writel(S3C_GINTSTS_NPTxFEmp, hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_PTxFEmp) {
@@ -2149,8 +2201,6 @@ irq_retry:
 
                 s3c_hsotg_disable_gsint(hsotg, S3C_GINTSTS_PTxFEmp);
                 s3c_hsotg_irq_fifoempty(hsotg, true);
-
-                writel(S3C_GINTSTS_PTxFEmp, hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_RxFLvl) {
@@ -2159,7 +2209,6 @@ irq_retry:
                  * set. */
 
                 s3c_hsotg_handle_rx(hsotg);
-                writel(S3C_GINTSTS_RxFLvl, hsotg->regs + S3C_GINTSTS);
         }
 
         if (gintsts & S3C_GINTSTS_ModeMis) {
@@ -2193,19 +2242,17 @@ irq_retry:
         if (gintsts & S3C_GINTSTS_GOUTNakEff) {
                 dev_info(hsotg->dev, "GOUTNakEff triggered\n");
 
-                s3c_hsotg_dump(hsotg);
-
                 writel(S3C_DCTL_CGOUTNak, hsotg->regs + S3C_DCTL);
-                writel(S3C_GINTSTS_GOUTNakEff, hsotg->regs + S3C_GINTSTS);
+
+                s3c_hsotg_dump(hsotg);
         }
 
         if (gintsts & S3C_GINTSTS_GINNakEff) {
                 dev_info(hsotg->dev, "GINNakEff triggered\n");
 
-                s3c_hsotg_dump(hsotg);
-
                 writel(S3C_DCTL_CGNPInNAK, hsotg->regs + S3C_DCTL);
-                writel(S3C_GINTSTS_GINNakEff, hsotg->regs + S3C_GINTSTS);
+
+                s3c_hsotg_dump(hsotg);
         }
 
         /* if we've had fifo events, we should try and go around the
@@ -2403,11 +2450,6 @@ static int s3c_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
 
         dev_info(hs->dev, "ep_dequeue(%p,%p)\n", ep, req);
 
-        if (hs_req == hs_ep->req) {
-                dev_dbg(hs->dev, "%s: already in progress\n", __func__);
-                return -EINPROGRESS;
-        }
-
         spin_lock_irqsave(&hs_ep->lock, flags);
 
         if (!on_list(hs_ep, hs_req)) {
@@ -2429,6 +2471,7 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
         unsigned long irqflags;
         u32 epreg;
         u32 epctl;
+        u32 xfertype;
 
         dev_info(hs->dev, "%s(ep %p %s, %d)\n", __func__, ep, ep->name, value);
 
@@ -2439,10 +2482,17 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
         epreg = S3C_DIEPCTL(index);
         epctl = readl(hs->regs + epreg);
 
-        if (value)
-                epctl |= S3C_DxEPCTL_Stall;
-        else
+        if (value) {
+                epctl |= S3C_DxEPCTL_Stall + S3C_DxEPCTL_SNAK;
+                if (epctl & S3C_DxEPCTL_EPEna)
+                        epctl |= S3C_DxEPCTL_EPDis;
+        } else {
                 epctl &= ~S3C_DxEPCTL_Stall;
+                xfertype = epctl & S3C_DxEPCTL_EPType_MASK;
+                if (xfertype == S3C_DxEPCTL_EPType_Bulk ||
+                        xfertype == S3C_DxEPCTL_EPType_Intterupt)
+                                epctl |= S3C_DxEPCTL_SetD0PID;
+        }
 
         writel(epctl, hs->regs + epreg);
 
@@ -2451,8 +2501,13 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
 
         if (value)
                 epctl |= S3C_DxEPCTL_Stall;
-        else
+        else {
                 epctl &= ~S3C_DxEPCTL_Stall;
+                xfertype = epctl & S3C_DxEPCTL_EPType_MASK;
+                if (xfertype == S3C_DxEPCTL_EPType_Bulk ||
+                        xfertype == S3C_DxEPCTL_EPType_Intterupt)
+                                epctl |= S3C_DxEPCTL_SetD0PID;
+        }
 
         writel(epctl, hs->regs + epreg);
 
@@ -2491,9 +2546,9 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
         timeout = 1000;
         do {
                 grstctl = readl(hsotg->regs + S3C_GRSTCTL);
-        } while (!(grstctl & S3C_GRSTCTL_CSftRst) && timeout-- > 0);
+        } while ((grstctl & S3C_GRSTCTL_CSftRst) && timeout-- > 0);
 
-        if (!(grstctl & S3C_GRSTCTL_CSftRst)) {
+        if (grstctl & S3C_GRSTCTL_CSftRst) {
                 dev_err(hsotg->dev, "Failed to get CSftRst asserted\n");
                 return -EINVAL;
         }
@@ -2510,9 +2565,6 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
                         return -ETIMEDOUT;
                 }
 
-                if (grstctl & S3C_GRSTCTL_CSftRst)
-                        continue;
-
                 if (!(grstctl & S3C_GRSTCTL_AHBIdle))
                         continue;
 
@@ -2588,6 +2640,12 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
 
         writel(1 << 18 | S3C_DCFG_DevSpd_HS,  hsotg->regs + S3C_DCFG);
 
+        /* Clear any pending OTG interrupts */
+        writel(0xffffffff, hsotg->regs + S3C_GOTGINT);
+
+        /* Clear any pending interrupts */
+        writel(0xffffffff, hsotg->regs + S3C_GINTSTS);
+
         writel(S3C_GINTSTS_DisconnInt | S3C_GINTSTS_SessReqInt |
                S3C_GINTSTS_ConIDStsChng | S3C_GINTSTS_USBRst |
                S3C_GINTSTS_EnumDone | S3C_GINTSTS_OTGInt |
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index b015561fd602..1fa4f705b0b4 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -708,13 +708,14 @@ static ssize_t fsg_show_file(struct device *dev, struct device_attribute *attr,
 static ssize_t fsg_store_ro(struct device *dev, struct device_attribute *attr,
                             const char *buf, size_t count)
 {
-        ssize_t         rc = count;
+        ssize_t         rc;
         struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
         struct rw_semaphore     *filesem = dev_get_drvdata(dev);
-        unsigned long   ro;
+        unsigned        ro;
 
-        if (strict_strtoul(buf, 2, &ro))
-                return -EINVAL;
+        rc = kstrtouint(buf, 2, &ro);
+        if (rc)
+                return rc;
 
         /*
          * Allow the write-enable status to change only while the
@@ -728,6 +729,7 @@ static ssize_t fsg_store_ro(struct device *dev, struct device_attribute *attr,
                 curlun->ro = ro;
                 curlun->initially_ro = ro;
                 LDBG(curlun, "read-only status set to %d\n", curlun->ro);
+                rc = count;
         }
         up_read(filesem);
         return rc;
@@ -738,10 +740,12 @@ static ssize_t fsg_store_nofua(struct device *dev,
                                const char *buf, size_t count)
 {
         struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
-        unsigned long   nofua;
+        unsigned        nofua;
+        int             ret;
 
-        if (strict_strtoul(buf, 2, &nofua))
-                return -EINVAL;
+        ret = kstrtouint(buf, 2, &nofua);
+        if (ret)
+                return ret;
 
         /* Sync data when switching from async mode to sync */
         if (!nofua && curlun->nofua)
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index e0e0787b724b..8898505af429 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -106,13 +106,13 @@ config USB_EHCI_BIG_ENDIAN_MMIO
         depends on USB_EHCI_HCD && (PPC_CELLEB || PPC_PS3 || 440EPX || \
                                     ARCH_IXP4XX || XPS_USB_HCD_XILINX || \
                                     PPC_MPC512x || CPU_CAVIUM_OCTEON || \
-                                    PMC_MSP)
+                                    PMC_MSP || SPARC_LEON)
         default y
 
 config USB_EHCI_BIG_ENDIAN_DESC
         bool
         depends on USB_EHCI_HCD && (440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX || \
-                                    PPC_MPC512x || PMC_MSP)
+                                    PPC_MPC512x || PMC_MSP || SPARC_LEON)
         default y
 
 config XPS_USB_HCD_XILINX
@@ -188,6 +188,12 @@ config USB_EHCI_SH
           Enables support for the on-chip EHCI controller on the SuperH.
           If you use the PCI EHCI controller, this option is not necessary.
 
+config USB_EHCI_S5P
+       boolean "S5P EHCI support"
+       depends on USB_EHCI_HCD && PLAT_S5P
+       help
+         Enable support for the S5P SOC's on-chip EHCI controller.
+
 config USB_W90X900_EHCI
         bool "W90X900(W90P910) EHCI support"
         depends on USB_EHCI_HCD && ARCH_W90X900
@@ -202,6 +208,15 @@ config USB_CNS3XXX_EHCI
           It is needed for high-speed (480Mbit/sec) USB 2.0 device
           support.
 
+config USB_EHCI_ATH79
+        bool "EHCI support for AR7XXX/AR9XXX SoCs"
+        depends on USB_EHCI_HCD && (SOC_AR71XX || SOC_AR724X || SOC_AR913X)
+        select USB_EHCI_ROOT_HUB_TT
+        default y
+        ---help---
+          Enables support for the built-in EHCI controller present
+          on the Atheros AR7XXX/AR9XXX SoCs.
+
 config USB_OXU210HP_HCD
         tristate "OXU210HP HCD support"
         depends on USB
@@ -287,6 +302,14 @@ config USB_OHCI_HCD_OMAP3
           Enables support for the on-chip OHCI controller on
           OMAP3 and later chips.
 
+config USB_OHCI_ATH79
+        bool "USB OHCI support for the Atheros AR71XX/AR7240 SoCs"
+        depends on USB_OHCI_HCD && (SOC_AR71XX || SOC_AR724X)
+        default y
+        help
+          Enables support for the built-in OHCI controller present on the
+          Atheros AR71XX/AR7240 SoCs.
+
 config USB_OHCI_HCD_PPC_SOC
         bool "OHCI support for on-chip PPC USB controller"
         depends on USB_OHCI_HCD && (STB03xxx || PPC_MPC52xx)
@@ -373,7 +396,7 @@ config USB_OHCI_LITTLE_ENDIAN
 
 config USB_UHCI_HCD
         tristate "UHCI HCD (most Intel and VIA) support"
-        depends on USB && PCI
+        depends on USB && (PCI || SPARC_LEON)
         ---help---
           The Universal Host Controller Interface is a standard by Intel for
           accessing the USB hardware in the PC (which is also called the USB
@@ -382,11 +405,17 @@ config USB_UHCI_HCD
           with Intel PCI chipsets (like intel 430TX, 440FX, 440LX, 440BX,
           i810, i820) conform to this standard. Also all VIA PCI chipsets
           (like VIA VP2, VP3, MVP3, Apollo Pro, Apollo Pro II or Apollo Pro
-          133). If unsure, say Y.
+          133) and LEON/GRLIB SoCs with the GRUSBHC controller.
+          If unsure, say Y.
 
           To compile this driver as a module, choose M here: the
           module will be called uhci-hcd.
 
+config USB_UHCI_SUPPORT_NON_PCI_HC
+        bool
+        depends on USB_UHCI_HCD
+        default y if SPARC_LEON
+
 config USB_FHCI_HCD
         tristate "Freescale QE USB Host Controller support"
         depends on USB && OF_GPIO && QE_GPIO && QUICC_ENGINE
@@ -444,6 +473,16 @@ config USB_SL811_HCD
           To compile this driver as a module, choose M here: the
           module will be called sl811-hcd.
 
+config USB_SL811_HCD_ISO
+        bool "partial ISO support"
+        depends on USB_SL811_HCD
+        help
+          The driver doesn't support iso_frame_desc (yet), but for some simple
+          devices that just queue one ISO frame per URB, then ISO transfers
+          "should" work using the normal urb status fields.
+
+          If unsure, say N.
+
 config USB_SL811_CS
         tristate "CF/PCMCIA support for SL811HS HCD"
         depends on USB_SL811_HCD && PCMCIA
diff --git a/drivers/usb/host/ehci-ath79.c b/drivers/usb/host/ehci-ath79.c
new file mode 100644
index 000000000000..98cc8a13169c
--- /dev/null
+++ b/drivers/usb/host/ehci-ath79.c
@@ -0,0 +1,202 @@
+/*
+ *  Bus Glue for Atheros AR7XXX/AR9XXX built-in EHCI controller.
+ *
+ *  Copyright (C) 2008-2011 Gabor Juhos <juhosg@openwrt.org>
+ *  Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org>
+ *
+ *  Parts of this file are based on Atheros' 2.6.15 BSP
+ *      Copyright (C) 2007 Atheros Communications, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 as published
+ *  by the Free Software Foundation.
+ */
+
+#include <linux/platform_device.h>
+
+enum {
+        EHCI_ATH79_IP_V1 = 0,
+        EHCI_ATH79_IP_V2,
+};
+
+static const struct platform_device_id ehci_ath79_id_table[] = {
+        {
+                .name           = "ar71xx-ehci",
+                .driver_data    = EHCI_ATH79_IP_V1,
+        },
+        {
+                .name           = "ar724x-ehci",
+                .driver_data    = EHCI_ATH79_IP_V2,
+        },
+        {
+                .name           = "ar913x-ehci",
+                .driver_data    = EHCI_ATH79_IP_V2,
+        },
+        {
+                /* terminating entry */
+        },
+};
+
+MODULE_DEVICE_TABLE(platform, ehci_ath79_id_table);
+
+static int ehci_ath79_init(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct platform_device *pdev = to_platform_device(hcd->self.controller);
+        const struct platform_device_id *id;
+        int hclength;
+        int ret;
+
+        id = platform_get_device_id(pdev);
+        if (!id) {
+                dev_err(hcd->self.controller, "missing device id\n");
+                return -EINVAL;
+        }
+
+        hclength = HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
+        switch (id->driver_data) {
+        case EHCI_ATH79_IP_V1:
+                ehci->has_synopsys_hc_bug = 1;
+
+                ehci->caps = hcd->regs;
+                ehci->regs = hcd->regs + hclength;
+                break;
+
+        case EHCI_ATH79_IP_V2:
+                hcd->has_tt = 1;
+
+                ehci->caps = hcd->regs + 0x100;
+                ehci->regs = hcd->regs + 0x100 + hclength;
+                break;
+
+        default:
+                BUG();
+        }
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+        ehci->sbrn = 0x20;
+
+        ehci_reset(ehci);
+
+        ret = ehci_init(hcd);
+        if (ret)
+                return ret;
+
+        ehci_port_power(ehci, 0);
+
+        return 0;
+}
+
+static const struct hc_driver ehci_ath79_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Atheros built-in EHCI controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        .reset                  = ehci_ath79_init,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        .get_frame_number       = ehci_get_frame,
+
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+};
+
+static int ehci_ath79_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res;
+        int irq;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_dbg(&pdev->dev, "no IRQ specified\n");
+                return -ENODEV;
+        }
+        irq = res->start;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_dbg(&pdev->dev, "no base address specified\n");
+                return -ENODEV;
+        }
+
+        hcd = usb_create_hcd(&ehci_ath79_hc_driver, &pdev->dev,
+                             dev_name(&pdev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len   = res->end - res->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                ret = -EBUSY;
+                goto err_put_hcd;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                ret = -EFAULT;
+                goto err_release_region;
+        }
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (ret)
+                goto err_iounmap;
+
+        return 0;
+
+err_iounmap:
+        iounmap(hcd->regs);
+
+err_release_region:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_put_hcd:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int ehci_ath79_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+static struct platform_driver ehci_ath79_driver = {
+        .probe          = ehci_ath79_probe,
+        .remove         = ehci_ath79_remove,
+        .id_table       = ehci_ath79_id_table,
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "ath79-ehci",
+        }
+};
+
+MODULE_ALIAS(PLATFORM_MODULE_PREFIX "ath79-ehci");
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index b2ed55cb811d..a5a3ef1f0096 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -56,7 +56,7 @@ static int ehci_atmel_setup(struct usb_hcd *hcd)
         /* registers start at offset 0x0 */
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
 
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index a869e3c103d3..42ae57409908 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -175,7 +175,8 @@ static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs + HC_LENGTH(readl(&ehci->caps->hc_capbase));
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, readl(&ehci->caps->hc_capbase));
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = readl(&ehci->caps->hcs_params);
 
@@ -215,10 +216,7 @@ static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
         struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         unsigned long flags;
-        int rc;
-
-        return 0;
-        rc = 0;
+        int rc = 0;
 
         if (time_before(jiffies, ehci->next_statechange))
                 msleep(10);
@@ -233,13 +231,13 @@ static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
         (void)ehci_readl(ehci, &ehci->regs->intr_enable);
 
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-
-        au1xxx_stop_ehc();
         spin_unlock_irqrestore(&ehci->lock, flags);
 
         // could save FLADJ in case of Vaux power loss
         // ... we'd only use it to handle clock skew
 
+        au1xxx_stop_ehc();
+
         return rc;
 }
 
diff --git a/drivers/usb/host/ehci-cns3xxx.c b/drivers/usb/host/ehci-cns3xxx.c
index 708a05b5d258..d41745c6f0c4 100644
--- a/drivers/usb/host/ehci-cns3xxx.c
+++ b/drivers/usb/host/ehci-cns3xxx.c
@@ -34,7 +34,7 @@ static int cns3xxx_ehci_init(struct usb_hcd *hcd)
 
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs
-                + HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                + HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
         hcd->has_tt = 0;
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 693c29b30521..40a844c1dbb4 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -726,7 +726,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
         }
 
         /* Capability Registers */
-        i = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
+        i = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         temp = scnprintf (next, size,
                 "bus %s, device %s\n"
                 "%s\n"
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 5c761df7fa83..f380bf97e5af 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -117,6 +117,9 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
 
         pdata->regs = hcd->regs;
 
+        if (pdata->power_budget)
+                hcd->power_budget = pdata->power_budget;
+
         /*
          * do platform specific init: check the clock, grab/config pins, etc.
          */
@@ -134,6 +137,30 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (retval != 0)
                 goto err4;
+
+#ifdef CONFIG_USB_OTG
+        if (pdata->operating_mode == FSL_USB2_DR_OTG) {
+                struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+                ehci->transceiver = otg_get_transceiver();
+                dev_dbg(&pdev->dev, "hcd=0x%p  ehci=0x%p, transceiver=0x%p\n",
+                        hcd, ehci, ehci->transceiver);
+
+                if (ehci->transceiver) {
+                        retval = otg_set_host(ehci->transceiver,
+                                              &ehci_to_hcd(ehci)->self);
+                        if (retval) {
+                                if (ehci->transceiver)
+                                        put_device(ehci->transceiver->dev);
+                                goto err4;
+                        }
+                } else {
+                        dev_err(&pdev->dev, "can't find transceiver\n");
+                        retval = -ENODEV;
+                        goto err4;
+                }
+        }
+#endif
         return retval;
 
       err4:
@@ -164,6 +191,12 @@ static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
                                struct platform_device *pdev)
 {
         struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        if (ehci->transceiver) {
+                otg_set_host(ehci->transceiver, NULL);
+                put_device(ehci->transceiver->dev);
+        }
 
         usb_remove_hcd(hcd);
 
@@ -291,7 +324,7 @@ static int ehci_fsl_setup(struct usb_hcd *hcd)
         /* EHCI registers start at offset 0x100 */
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-            HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
 
@@ -328,6 +361,149 @@ struct ehci_fsl {
 
 #ifdef CONFIG_PM
 
+#ifdef CONFIG_PPC_MPC512x
+static int ehci_fsl_mpc512x_drv_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct fsl_usb2_platform_data *pdata = dev->platform_data;
+        u32 tmp;
+
+#ifdef DEBUG
+        u32 mode = ehci_readl(ehci, hcd->regs + FSL_SOC_USB_USBMODE);
+        mode &= USBMODE_CM_MASK;
+        tmp = ehci_readl(ehci, hcd->regs + 0x140);      /* usbcmd */
+
+        dev_dbg(dev, "suspend=%d already_suspended=%d "
+                "mode=%d  usbcmd %08x\n", pdata->suspended,
+                pdata->already_suspended, mode, tmp);
+#endif
+
+        /*
+         * If the controller is already suspended, then this must be a
+         * PM suspend.  Remember this fact, so that we will leave the
+         * controller suspended at PM resume time.
+         */
+        if (pdata->suspended) {
+                dev_dbg(dev, "already suspended, leaving early\n");
+                pdata->already_suspended = 1;
+                return 0;
+        }
+
+        dev_dbg(dev, "suspending...\n");
+
+        hcd->state = HC_STATE_SUSPENDED;
+        dev->power.power_state = PMSG_SUSPEND;
+
+        /* ignore non-host interrupts */
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        /* stop the controller */
+        tmp = ehci_readl(ehci, &ehci->regs->command);
+        tmp &= ~CMD_RUN;
+        ehci_writel(ehci, tmp, &ehci->regs->command);
+
+        /* save EHCI registers */
+        pdata->pm_command = ehci_readl(ehci, &ehci->regs->command);
+        pdata->pm_command &= ~CMD_RUN;
+        pdata->pm_status  = ehci_readl(ehci, &ehci->regs->status);
+        pdata->pm_intr_enable  = ehci_readl(ehci, &ehci->regs->intr_enable);
+        pdata->pm_frame_index  = ehci_readl(ehci, &ehci->regs->frame_index);
+        pdata->pm_segment  = ehci_readl(ehci, &ehci->regs->segment);
+        pdata->pm_frame_list  = ehci_readl(ehci, &ehci->regs->frame_list);
+        pdata->pm_async_next  = ehci_readl(ehci, &ehci->regs->async_next);
+        pdata->pm_configured_flag  =
+                ehci_readl(ehci, &ehci->regs->configured_flag);
+        pdata->pm_portsc = ehci_readl(ehci, &ehci->regs->port_status[0]);
+        pdata->pm_usbgenctrl = ehci_readl(ehci,
+                                          hcd->regs + FSL_SOC_USB_USBGENCTRL);
+
+        /* clear the W1C bits */
+        pdata->pm_portsc &= cpu_to_hc32(ehci, ~PORT_RWC_BITS);
+
+        pdata->suspended = 1;
+
+        /* clear PP to cut power to the port */
+        tmp = ehci_readl(ehci, &ehci->regs->port_status[0]);
+        tmp &= ~PORT_POWER;
+        ehci_writel(ehci, tmp, &ehci->regs->port_status[0]);
+
+        return 0;
+}
+
+static int ehci_fsl_mpc512x_drv_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct fsl_usb2_platform_data *pdata = dev->platform_data;
+        u32 tmp;
+
+        dev_dbg(dev, "suspend=%d already_suspended=%d\n",
+                pdata->suspended, pdata->already_suspended);
+
+        /*
+         * If the controller was already suspended at suspend time,
+         * then don't resume it now.
+         */
+        if (pdata->already_suspended) {
+                dev_dbg(dev, "already suspended, leaving early\n");
+                pdata->already_suspended = 0;
+                return 0;
+        }
+
+        if (!pdata->suspended) {
+                dev_dbg(dev, "not suspended, leaving early\n");
+                return 0;
+        }
+
+        pdata->suspended = 0;
+
+        dev_dbg(dev, "resuming...\n");
+
+        /* set host mode */
+        tmp = USBMODE_CM_HOST | (pdata->es ? USBMODE_ES : 0);
+        ehci_writel(ehci, tmp, hcd->regs + FSL_SOC_USB_USBMODE);
+
+        ehci_writel(ehci, pdata->pm_usbgenctrl,
+                    hcd->regs + FSL_SOC_USB_USBGENCTRL);
+        ehci_writel(ehci, ISIPHYCTRL_PXE | ISIPHYCTRL_PHYE,
+                    hcd->regs + FSL_SOC_USB_ISIPHYCTRL);
+
+        /* restore EHCI registers */
+        ehci_writel(ehci, pdata->pm_command, &ehci->regs->command);
+        ehci_writel(ehci, pdata->pm_intr_enable, &ehci->regs->intr_enable);
+        ehci_writel(ehci, pdata->pm_frame_index, &ehci->regs->frame_index);
+        ehci_writel(ehci, pdata->pm_segment, &ehci->regs->segment);
+        ehci_writel(ehci, pdata->pm_frame_list, &ehci->regs->frame_list);
+        ehci_writel(ehci, pdata->pm_async_next, &ehci->regs->async_next);
+        ehci_writel(ehci, pdata->pm_configured_flag,
+                    &ehci->regs->configured_flag);
+        ehci_writel(ehci, pdata->pm_portsc, &ehci->regs->port_status[0]);
+
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        hcd->state = HC_STATE_RUNNING;
+        dev->power.power_state = PMSG_ON;
+
+        tmp = ehci_readl(ehci, &ehci->regs->command);
+        tmp |= CMD_RUN;
+        ehci_writel(ehci, tmp, &ehci->regs->command);
+
+        usb_hcd_resume_root_hub(hcd);
+
+        return 0;
+}
+#else
+static inline int ehci_fsl_mpc512x_drv_suspend(struct device *dev)
+{
+        return 0;
+}
+
+static inline int ehci_fsl_mpc512x_drv_resume(struct device *dev)
+{
+        return 0;
+}
+#endif /* CONFIG_PPC_MPC512x */
+
 static struct ehci_fsl *hcd_to_ehci_fsl(struct usb_hcd *hcd)
 {
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
@@ -341,6 +517,11 @@ static int ehci_fsl_drv_suspend(struct device *dev)
         struct ehci_fsl *ehci_fsl = hcd_to_ehci_fsl(hcd);
         void __iomem *non_ehci = hcd->regs;
 
+        if (of_device_is_compatible(dev->parent->of_node,
+                                    "fsl,mpc5121-usb2-dr")) {
+                return ehci_fsl_mpc512x_drv_suspend(dev);
+        }
+
         ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd),
                         device_may_wakeup(dev));
         if (!fsl_deep_sleep())
@@ -357,6 +538,11 @@ static int ehci_fsl_drv_resume(struct device *dev)
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         void __iomem *non_ehci = hcd->regs;
 
+        if (of_device_is_compatible(dev->parent->of_node,
+                                    "fsl,mpc5121-usb2-dr")) {
+                return ehci_fsl_mpc512x_drv_resume(dev);
+        }
+
         ehci_prepare_ports_for_controller_resume(ehci);
         if (!fsl_deep_sleep())
                 return 0;
@@ -391,6 +577,38 @@ static struct dev_pm_ops ehci_fsl_pm_ops = {
 #define EHCI_FSL_PM_OPS         NULL
 #endif /* CONFIG_PM */
 
+#ifdef CONFIG_USB_OTG
+static int ehci_start_port_reset(struct usb_hcd *hcd, unsigned port)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        u32 status;
+
+        if (!port)
+                return -EINVAL;
+
+        port--;
+
+        /* start port reset before HNP protocol time out */
+        status = readl(&ehci->regs->port_status[port]);
+        if (!(status & PORT_CONNECT))
+                return -ENODEV;
+
+        /* khubd will finish the reset later */
+        if (ehci_is_TDI(ehci)) {
+                writel(PORT_RESET |
+                       (status & ~(PORT_CSC | PORT_PEC | PORT_OCC)),
+                       &ehci->regs->port_status[port]);
+        } else {
+                writel(PORT_RESET, &ehci->regs->port_status[port]);
+        }
+
+        return 0;
+}
+#else
+#define ehci_start_port_reset   NULL
+#endif /* CONFIG_USB_OTG */
+
+
 static const struct hc_driver ehci_fsl_hc_driver = {
         .description = hcd_name,
         .product_desc = "Freescale On-Chip EHCI Host Controller",
@@ -430,6 +648,7 @@ static const struct hc_driver ehci_fsl_hc_driver = {
         .hub_control = ehci_hub_control,
         .bus_suspend = ehci_bus_suspend,
         .bus_resume = ehci_bus_resume,
+        .start_port_reset = ehci_start_port_reset,
         .relinquish_port = ehci_relinquish_port,
         .port_handed_over = ehci_port_handed_over,
 
diff --git a/drivers/usb/host/ehci-fsl.h b/drivers/usb/host/ehci-fsl.h
index 3fabed33d940..491806221165 100644
--- a/drivers/usb/host/ehci-fsl.h
+++ b/drivers/usb/host/ehci-fsl.h
@@ -27,6 +27,10 @@
 #define PORT_PTS_SERIAL         (3<<30)
 #define PORT_PTS_PTW            (1<<28)
 #define FSL_SOC_USB_PORTSC2     0x188
+#define FSL_SOC_USB_USBMODE     0x1a8
+#define USBMODE_CM_MASK         (3 << 0)        /* controller mode mask */
+#define USBMODE_CM_HOST         (3 << 0)        /* controller mode: host */
+#define USBMODE_ES              (1 << 2)        /* (Big) Endian Select */
 
 #define FSL_SOC_USB_USBGENCTRL  0x200
 #define USBGENCTRL_PPP          (1 << 3)
diff --git a/drivers/usb/host/ehci-grlib.c b/drivers/usb/host/ehci-grlib.c
new file mode 100644
index 000000000000..93b230dc51a2
--- /dev/null
+++ b/drivers/usb/host/ehci-grlib.c
@@ -0,0 +1,242 @@
+/*
+ * Driver for Aeroflex Gaisler GRLIB GRUSBHC EHCI host controller
+ *
+ * GRUSBHC is typically found on LEON/GRLIB SoCs
+ *
+ * (c) Jan Andersson <jan@gaisler.com>
+ *
+ * Based on ehci-ppc-of.c which is:
+ * (c) Valentine Barshak <vbarshak@ru.mvista.com>
+ * and in turn based on "ehci-ppc-soc.c" by Stefan Roese <sr@denx.de>
+ * and "ohci-ppc-of.c" by Sylvain Munaut <tnt@246tNt.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <linux/signal.h>
+
+#include <linux/of_irq.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+
+#define GRUSBHC_HCIVERSION 0x0100 /* Known value of cap. reg. HCIVERSION */
+
+/* called during probe() after chip reset completes */
+static int ehci_grlib_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int             retval;
+
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci->sbrn = 0x20;
+        ehci_port_power(ehci, 1);
+
+        return ehci_reset(ehci);
+}
+
+
+static const struct hc_driver ehci_grlib_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "GRLIB GRUSBHC EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                  = ehci_grlib_setup,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+#ifdef  CONFIG_PM
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+#endif
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+
+static int __devinit ehci_hcd_grlib_probe(struct platform_device *op)
+{
+        struct device_node *dn = op->dev.of_node;
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci = NULL;
+        struct resource res;
+        u32 hc_capbase;
+        int irq;
+        int rv;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        dev_dbg(&op->dev, "initializing GRUSBHC EHCI USB Controller\n");
+
+        rv = of_address_to_resource(dn, 0, &res);
+        if (rv)
+                return rv;
+
+        /* usb_create_hcd requires dma_mask != NULL */
+        op->dev.dma_mask = &op->dev.coherent_dma_mask;
+        hcd = usb_create_hcd(&ehci_grlib_hc_driver, &op->dev,
+                        "GRUSBHC EHCI USB");
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res.start;
+        hcd->rsrc_len = res.end - res.start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_rmr;
+        }
+
+        irq = irq_of_parse_and_map(dn, 0);
+        if (irq == NO_IRQ) {
+                printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_irq;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
+                rv = -ENOMEM;
+                goto err_ioremap;
+        }
+
+        ehci = hcd_to_ehci(hcd);
+
+        ehci->caps = hcd->regs;
+
+        /* determine endianness of this implementation */
+        hc_capbase = ehci_readl(ehci, &ehci->caps->hc_capbase);
+        if (HC_VERSION(ehci, hc_capbase) != GRUSBHC_HCIVERSION) {
+                ehci->big_endian_mmio = 1;
+                ehci->big_endian_desc = 1;
+                ehci->big_endian_capbase = 1;
+        }
+
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        rv = usb_add_hcd(hcd, irq, 0);
+        if (rv)
+                goto err_ehci;
+
+        return 0;
+
+err_ehci:
+        iounmap(hcd->regs);
+err_ioremap:
+        irq_dispose_mapping(irq);
+err_irq:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_rmr:
+        usb_put_hcd(hcd);
+
+        return rv;
+}
+
+
+static int ehci_hcd_grlib_remove(struct platform_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        dev_set_drvdata(&op->dev, NULL);
+
+        dev_dbg(&op->dev, "stopping GRLIB GRUSBHC EHCI USB Controller\n");
+
+        usb_remove_hcd(hcd);
+
+        iounmap(hcd->regs);
+        irq_dispose_mapping(hcd->irq);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+
+static void ehci_hcd_grlib_shutdown(struct platform_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+
+static const struct of_device_id ehci_hcd_grlib_of_match[] = {
+        {
+                .name = "GAISLER_EHCI",
+         },
+        {
+                .name = "01_026",
+         },
+        {},
+};
+MODULE_DEVICE_TABLE(of, ehci_hcd_grlib_of_match);
+
+
+static struct platform_driver ehci_grlib_driver = {
+        .probe          = ehci_hcd_grlib_probe,
+        .remove         = ehci_hcd_grlib_remove,
+        .shutdown       = ehci_hcd_grlib_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 78561d112c04..c5719cd258c3 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -739,7 +739,7 @@ static int ehci_run (struct usb_hcd *hcd)
         up_write(&ehci_cf_port_reset_rwsem);
         ehci->last_periodic_enable = ktime_get_real();
 
-        temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
+        temp = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci_info (ehci,
                 "USB %x.%x started, EHCI %x.%02x%s\n",
                 ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
@@ -1265,6 +1265,21 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         tegra_ehci_driver
 #endif
 
+#ifdef CONFIG_USB_EHCI_S5P
+#include "ehci-s5p.c"
+#define PLATFORM_DRIVER         s5p_ehci_driver
+#endif
+
+#ifdef CONFIG_USB_EHCI_ATH79
+#include "ehci-ath79.c"
+#define PLATFORM_DRIVER         ehci_ath79_driver
+#endif
+
+#ifdef CONFIG_SPARC_LEON
+#include "ehci-grlib.c"
+#define PLATFORM_DRIVER         ehci_grlib_driver
+#endif
+
 #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
     !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
     !defined(XILINX_OF_PLATFORM_DRIVER)
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index d05ea03cfb4d..ea6184bf48d0 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -27,6 +27,7 @@
  */
 
 /*-------------------------------------------------------------------------*/
+#include <linux/usb/otg.h>
 
 #define PORT_WAKE_BITS  (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
 
@@ -127,7 +128,7 @@ static int ehci_port_change(struct ehci_hcd *ehci)
         return 0;
 }
 
-static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
+static __maybe_unused void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
                 bool suspending, bool do_wakeup)
 {
         int             port;
@@ -801,6 +802,13 @@ static int ehci_hub_control (
                                 goto error;
                         if (ehci->no_selective_suspend)
                                 break;
+#ifdef CONFIG_USB_OTG
+                        if ((hcd->self.otg_port == (wIndex + 1))
+                            && hcd->self.b_hnp_enable) {
+                                otg_start_hnp(ehci->transceiver);
+                                break;
+                        }
+#endif
                         if (!(temp & PORT_SUSPEND))
                                 break;
                         if ((temp & PORT_PE) == 0)
diff --git a/drivers/usb/host/ehci-ixp4xx.c b/drivers/usb/host/ehci-ixp4xx.c
index 89b7c70c6ed6..50e600d26e28 100644
--- a/drivers/usb/host/ehci-ixp4xx.c
+++ b/drivers/usb/host/ehci-ixp4xx.c
@@ -23,7 +23,7 @@ static int ixp4xx_ehci_init(struct usb_hcd *hcd)
 
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100
-                + HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                + HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
         hcd->has_tt = 1;
diff --git a/drivers/usb/host/ehci-msm.c b/drivers/usb/host/ehci-msm.c
index 9ce1b0bc186d..b5a0bf649c95 100644
--- a/drivers/usb/host/ehci-msm.c
+++ b/drivers/usb/host/ehci-msm.c
@@ -41,7 +41,7 @@ static int ehci_msm_reset(struct usb_hcd *hcd)
 
         ehci->caps = USB_CAPLENGTH;
         ehci->regs = USB_CAPLENGTH +
-                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
 
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index 25c8c10bb689..0c058be35a38 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -208,7 +208,7 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         /* EHCI registers start at offset 0x100 */
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-            HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         /* set up the PORTSCx register */
         ehci_writel(ehci, pdata->portsc, &ehci->regs->port_status[0]);
diff --git a/drivers/usb/host/ehci-octeon.c b/drivers/usb/host/ehci-octeon.c
index a31a031178a8..ff55757ba7d8 100644
--- a/drivers/usb/host/ehci-octeon.c
+++ b/drivers/usb/host/ehci-octeon.c
@@ -151,7 +151,7 @@ static int ehci_octeon_drv_probe(struct platform_device *pdev)
 
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 627f3a678759..55a57c23dd0f 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -208,7 +208,7 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
         /* we know this is the memory we want, no need to ioremap again */
         omap_ehci->caps = hcd->regs;
         omap_ehci->regs = hcd->regs
-                        + HC_LENGTH(readl(&omap_ehci->caps->hc_capbase));
+                + HC_LENGTH(ehci, readl(&omap_ehci->caps->hc_capbase));
 
         dbg_hcs_params(omap_ehci, "reset");
         dbg_hcc_params(omap_ehci, "reset");
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index 281e094e1c18..395bdb0248d5 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -251,7 +251,7 @@ static int __devinit ehci_orion_drv_probe(struct platform_device *pdev)
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
         hcd->has_tt = 1;
         ehci->sbrn = 0x20;
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index d5eaea7caf89..660b80a75cac 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -70,7 +70,7 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
 
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
diff --git a/drivers/usb/host/ehci-pmcmsp.c b/drivers/usb/host/ehci-pmcmsp.c
index a2168642175b..cd69099cda19 100644
--- a/drivers/usb/host/ehci-pmcmsp.c
+++ b/drivers/usb/host/ehci-pmcmsp.c
@@ -83,7 +83,7 @@ static int ehci_msp_setup(struct usb_hcd *hcd)
 
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                        HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
 
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index 1f09f253697e..8552db6c29c9 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -179,7 +179,7 @@ static int __devinit ehci_hcd_ppc_of_probe(struct platform_device *op)
 
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                        HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
diff --git a/drivers/usb/host/ehci-ps3.c b/drivers/usb/host/ehci-ps3.c
index 1dee33b9139e..64626a777d61 100644
--- a/drivers/usb/host/ehci-ps3.c
+++ b/drivers/usb/host/ehci-ps3.c
@@ -29,7 +29,7 @@ static int ps3_ehci_hc_reset(struct usb_hcd *hcd)
         ehci->big_endian_mmio = 1;
 
         ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs + HC_LENGTH(ehci_readl(ehci,
+        ehci->regs = hcd->regs + HC_LENGTH(ehci, ehci_readl(ehci,
                 &ehci->caps->hc_capbase));
 
         dbg_hcs_params(ehci, "reset");
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 42abd0f603bf..a46d6a1388c9 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -1183,6 +1183,10 @@ static void end_unlink_async (struct ehci_hcd *ehci)
                 ehci->reclaim = NULL;
                 start_unlink_async (ehci, next);
         }
+
+        if (ehci->has_synopsys_hc_bug)
+                ehci_writel(ehci, (u32) ehci->async->qh_dma,
+                            &ehci->regs->async_next);
 }
 
 /* makes sure the async qh will become idle */
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
new file mode 100644
index 000000000000..321a03301ad2
--- /dev/null
+++ b/drivers/usb/host/ehci-s5p.c
@@ -0,0 +1,202 @@
+/*
+ * SAMSUNG S5P USB HOST EHCI Controller
+ *
+ * Copyright (C) 2011 Samsung Electronics Co.Ltd
+ * Author: Jingoo Han <jg1.han@samsung.com>
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <mach/regs-pmu.h>
+#include <plat/cpu.h>
+#include <plat/ehci.h>
+#include <plat/usb-phy.h>
+
+struct s5p_ehci_hcd {
+        struct device *dev;
+        struct usb_hcd *hcd;
+        struct clk *clk;
+};
+
+static const struct hc_driver s5p_ehci_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "S5P EHCI Host Controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        .reset                  = ehci_init,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        .get_frame_number       = ehci_get_frame,
+
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int s5p_ehci_probe(struct platform_device *pdev)
+{
+        struct s5p_ehci_platdata *pdata;
+        struct s5p_ehci_hcd *s5p_ehci;
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci;
+        struct resource *res;
+        int irq;
+        int err;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "No platform data defined\n");
+                return -EINVAL;
+        }
+
+        s5p_ehci = kzalloc(sizeof(struct s5p_ehci_hcd), GFP_KERNEL);
+        if (!s5p_ehci)
+                return -ENOMEM;
+
+        s5p_ehci->dev = &pdev->dev;
+
+        hcd = usb_create_hcd(&s5p_ehci_hc_driver, &pdev->dev,
+                                        dev_name(&pdev->dev));
+        if (!hcd) {
+                dev_err(&pdev->dev, "Unable to create HCD\n");
+                err = -ENOMEM;
+                goto fail_hcd;
+        }
+
+        s5p_ehci->clk = clk_get(&pdev->dev, "usbhost");
+
+        if (IS_ERR(s5p_ehci->clk)) {
+                dev_err(&pdev->dev, "Failed to get usbhost clock\n");
+                err = PTR_ERR(s5p_ehci->clk);
+                goto fail_clk;
+        }
+
+        err = clk_enable(s5p_ehci->clk);
+        if (err)
+                goto fail_clken;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Failed to get I/O memory\n");
+                err = -ENXIO;
+                goto fail_io;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+        hcd->regs = ioremap(res->start, resource_size(res));
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "Failed to remap I/O memory\n");
+                err = -ENOMEM;
+                goto fail_io;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (!irq) {
+                dev_err(&pdev->dev, "Failed to get IRQ\n");
+                err = -ENODEV;
+                goto fail;
+        }
+
+        if (pdata->phy_init)
+                pdata->phy_init(pdev, S5P_USB_PHY_HOST);
+
+        ehci = hcd_to_ehci(hcd);
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, readl(&ehci->caps->hc_capbase));
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = readl(&ehci->caps->hcs_params);
+
+        err = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (err) {
+                dev_err(&pdev->dev, "Failed to add USB HCD\n");
+                goto fail;
+        }
+
+        platform_set_drvdata(pdev, s5p_ehci);
+
+        return 0;
+
+fail:
+        iounmap(hcd->regs);
+fail_io:
+        clk_disable(s5p_ehci->clk);
+fail_clken:
+        clk_put(s5p_ehci->clk);
+fail_clk:
+        usb_put_hcd(hcd);
+fail_hcd:
+        kfree(s5p_ehci);
+        return err;
+}
+
+static int s5p_ehci_remove(struct platform_device *pdev)
+{
+        struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
+        struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = s5p_ehci->hcd;
+
+        usb_remove_hcd(hcd);
+
+        if (pdata && pdata->phy_exit)
+                pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
+
+        iounmap(hcd->regs);
+
+        clk_disable(s5p_ehci->clk);
+        clk_put(s5p_ehci->clk);
+
+        usb_put_hcd(hcd);
+        kfree(s5p_ehci);
+
+        return 0;
+}
+
+static void s5p_ehci_shutdown(struct platform_device *pdev)
+{
+        struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = s5p_ehci->hcd;
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+static struct platform_driver s5p_ehci_driver = {
+        .probe          = s5p_ehci_probe,
+        .remove         = s5p_ehci_remove,
+        .shutdown       = s5p_ehci_shutdown,
+        .driver = {
+                .name   = "s5p-ehci",
+                .owner  = THIS_MODULE,
+        }
+};
+
+MODULE_ALIAS("platform:s5p-ehci");
diff --git a/drivers/usb/host/ehci-sh.c b/drivers/usb/host/ehci-sh.c
index 595f70f42b52..86a95bb80a61 100644
--- a/drivers/usb/host/ehci-sh.c
+++ b/drivers/usb/host/ehci-sh.c
@@ -23,7 +23,7 @@ static int ehci_sh_reset(struct usb_hcd *hcd)
         int ret;
 
         ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs + HC_LENGTH(ehci_readl(ehci,
+        ehci->regs = hcd->regs + HC_LENGTH(ehci, ehci_readl(ehci,
                 &ehci->caps->hc_capbase));
 
         dbg_hcs_params(ehci, "reset");
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
index 75c00873443d..dbf1e4ef3c17 100644
--- a/drivers/usb/host/ehci-spear.c
+++ b/drivers/usb/host/ehci-spear.c
@@ -38,7 +38,7 @@ static int ehci_spear_setup(struct usb_hcd *hcd)
 
         /* registers start at offset 0x0 */
         ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs + HC_LENGTH(ehci_readl(ehci,
+        ehci->regs = hcd->regs + HC_LENGTH(ehci, ehci_readl(ehci,
                                 &ehci->caps->hc_capbase));
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index a516af28c29b..02b2bfd49a10 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -58,6 +58,71 @@ static void tegra_ehci_power_down(struct usb_hcd *hcd)
         clk_disable(tegra->emc_clk);
 }
 
+static int tegra_ehci_internal_port_reset(
+        struct ehci_hcd *ehci,
+        u32 __iomem     *portsc_reg
+)
+{
+        u32             temp;
+        unsigned long   flags;
+        int             retval = 0;
+        int             i, tries;
+        u32             saved_usbintr;
+
+        spin_lock_irqsave(&ehci->lock, flags);
+        saved_usbintr = ehci_readl(ehci, &ehci->regs->intr_enable);
+        /* disable USB interrupt */
+        ehci_writel(ehci, 0, &ehci->regs->intr_enable);
+        spin_unlock_irqrestore(&ehci->lock, flags);
+
+        /*
+         * Here we have to do Port Reset at most twice for
+         * Port Enable bit to be set.
+         */
+        for (i = 0; i < 2; i++) {
+                temp = ehci_readl(ehci, portsc_reg);
+                temp |= PORT_RESET;
+                ehci_writel(ehci, temp, portsc_reg);
+                mdelay(10);
+                temp &= ~PORT_RESET;
+                ehci_writel(ehci, temp, portsc_reg);
+                mdelay(1);
+                tries = 100;
+                do {
+                        mdelay(1);
+                        /*
+                         * Up to this point, Port Enable bit is
+                         * expected to be set after 2 ms waiting.
+                         * USB1 usually takes extra 45 ms, for safety,
+                         * we take 100 ms as timeout.
+                         */
+                        temp = ehci_readl(ehci, portsc_reg);
+                } while (!(temp & PORT_PE) && tries--);
+                if (temp & PORT_PE)
+                        break;
+        }
+        if (i == 2)
+                retval = -ETIMEDOUT;
+
+        /*
+         * Clear Connect Status Change bit if it's set.
+         * We can't clear PORT_PEC. It will also cause PORT_PE to be cleared.
+         */
+        if (temp & PORT_CSC)
+                ehci_writel(ehci, PORT_CSC, portsc_reg);
+
+        /*
+         * Write to clear any interrupt status bits that might be set
+         * during port reset.
+         */
+        temp = ehci_readl(ehci, &ehci->regs->status);
+        ehci_writel(ehci, temp, &ehci->regs->status);
+
+        /* restore original interrupt enable bits */
+        ehci_writel(ehci, saved_usbintr, &ehci->regs->intr_enable);
+        return retval;
+}
+
 static int tegra_ehci_hub_control(
         struct usb_hcd  *hcd,
         u16             typeReq,
@@ -121,6 +186,13 @@ static int tegra_ehci_hub_control(
                 goto done;
         }
 
+        /* For USB1 port we need to issue Port Reset twice internally */
+        if (tegra->phy->instance == 0 &&
+           (typeReq == SetPortFeature && wValue == USB_PORT_FEAT_RESET)) {
+                spin_unlock_irqrestore(&ehci->lock, flags);
+                return tegra_ehci_internal_port_reset(ehci, status_reg);
+        }
+
         /*
          * Tegra host controller will time the resume operation to clear the bit
          * when the port control state switches to HS or FS Idle. This behavior
@@ -328,7 +400,7 @@ static int tegra_ehci_setup(struct usb_hcd *hcd)
         /* EHCI registers start at offset 0x100 */
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-                HC_LENGTH(readl(&ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, readl(&ehci->caps->hc_capbase));
 
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
diff --git a/drivers/usb/host/ehci-vt8500.c b/drivers/usb/host/ehci-vt8500.c
index 20168062035a..47d749631bc7 100644
--- a/drivers/usb/host/ehci-vt8500.c
+++ b/drivers/usb/host/ehci-vt8500.c
@@ -121,7 +121,8 @@ static int vt8500_ehci_drv_probe(struct platform_device *pdev)
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs + HC_LENGTH(readl(&ehci->caps->hc_capbase));
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci, readl(&ehci->caps->hc_capbase));
 
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
diff --git a/drivers/usb/host/ehci-w90x900.c b/drivers/usb/host/ehci-w90x900.c
index 6bc35809a5c6..52a027aaa370 100644
--- a/drivers/usb/host/ehci-w90x900.c
+++ b/drivers/usb/host/ehci-w90x900.c
@@ -57,7 +57,7 @@ static int __devinit usb_w90x900_probe(const struct hc_driver *driver,
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs +
-                 HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         /* enable PHY 0,1,the regs only apply to w90p910
         *  0xA4,0xA8 were offsets of PHY0 and PHY1 controller of
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
index effc58d7af8b..a64d6d66d760 100644
--- a/drivers/usb/host/ehci-xilinx-of.c
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -220,7 +220,7 @@ static int __devinit ehci_hcd_xilinx_of_probe(struct platform_device *op)
          */
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-                        HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 333ddc156919..829213423dea 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -128,12 +128,14 @@ struct ehci_hcd {			/* one per controller */
         unsigned                has_fsl_port_bug:1; /* FreeScale */
         unsigned                big_endian_mmio:1;
         unsigned                big_endian_desc:1;
+        unsigned                big_endian_capbase:1;
         unsigned                has_amcc_usb23:1;
         unsigned                need_io_watchdog:1;
         unsigned                broken_periodic:1;
         unsigned                amd_pll_fix:1;
         unsigned                fs_i_thresh:1;  /* Intel iso scheduling */
         unsigned                use_dummy_qh:1; /* AMD Frame List table quirk*/
+        unsigned                has_synopsys_hc_bug:1; /* Synopsys HC */
 
         /* required for usb32 quirk */
         #define OHCI_CTRL_HCFS          (3 << 6)
@@ -160,6 +162,10 @@ struct ehci_hcd {			/* one per controller */
 #ifdef DEBUG
         struct dentry           *debug_dir;
 #endif
+        /*
+         * OTG controllers and transceivers need software interaction
+         */
+        struct otg_transceiver  *transceiver;
 };
 
 /* convert between an HCD pointer and the corresponding EHCI_HCD */
@@ -600,12 +606,18 @@ ehci_port_speed(struct ehci_hcd *ehci, unsigned int portsc)
  * This attempts to support either format at compile time without a
  * runtime penalty, or both formats with the additional overhead
  * of checking a flag bit.
+ *
+ * ehci_big_endian_capbase is a special quirk for controllers that
+ * implement the HC capability registers as separate registers and not
+ * as fields of a 32-bit register.
  */
 
 #ifdef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
 #define ehci_big_endian_mmio(e)         ((e)->big_endian_mmio)
+#define ehci_big_endian_capbase(e)      ((e)->big_endian_capbase)
 #else
 #define ehci_big_endian_mmio(e)         0
+#define ehci_big_endian_capbase(e)      0
 #endif
 
 /*
@@ -615,6 +627,9 @@ ehci_port_speed(struct ehci_hcd *ehci, unsigned int portsc)
 #if defined(CONFIG_ARM) && defined(CONFIG_ARCH_IXP4XX)
 #define readl_be(addr)          __raw_readl((__force unsigned *)addr)
 #define writel_be(val, addr)    __raw_writel(val, (__force unsigned *)addr)
+#elif defined(CONFIG_SPARC_LEON)
+#define readl_be(addr)          __raw_readl(addr)
+#define writel_be(val, addr)    __raw_writel(val, addr)
 #endif
 
 static inline unsigned int ehci_readl(const struct ehci_hcd *ehci,
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 7b2e69aa2e98..dd98a966b58b 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -8,6 +8,8 @@
  *
  * (c) 2007 Sebastian Siewior <bigeasy@linutronix.de>
  *
+ * (c) 2011 Arvid Brodin <arvid.brodin@enea.com>
+ *
  */
 #include <linux/module.h>
 #include <linux/kernel.h>
@@ -26,14 +28,16 @@
 
 static struct kmem_cache *qtd_cachep;
 static struct kmem_cache *qh_cachep;
+static struct kmem_cache *urb_listitem_cachep;
 
 struct isp1760_hcd {
         u32 hcs_params;
         spinlock_t              lock;
-        struct inter_packet_info atl_ints[32];
-        struct inter_packet_info int_ints[32];
+        struct slotinfo         atl_slots[32];
+        struct slotinfo         int_slots[32];
         struct memory_chunk memory_pool[BLOCKS];
-        u32 atl_queued;
+        struct list_head        controlqhs, bulkqhs, interruptqhs;
+        int active_ptds;
 
         /* periodic schedule support */
 #define DEFAULT_I_TDPS          1024
@@ -85,18 +89,34 @@ struct isp1760_qtd {
         struct list_head qtd_list;
         struct urb *urb;
         size_t length;
-
-        /* isp special*/
+        size_t actual_length;
+
+        /* QTD_ENQUEUED:        waiting for transfer (inactive) */
+        /* QTD_PAYLOAD_ALLOC:   chip mem has been allocated for payload */
+        /* QTD_XFER_STARTED:    valid ptd has been written to isp176x - only
+                                interrupt handler may touch this qtd! */
+        /* QTD_XFER_COMPLETE:   payload has been transferred successfully */
+        /* QTD_RETIRE:          transfer error/abort qtd */
+#define QTD_ENQUEUED            0
+#define QTD_PAYLOAD_ALLOC       1
+#define QTD_XFER_STARTED        2
+#define QTD_XFER_COMPLETE       3
+#define QTD_RETIRE              4
         u32 status;
-#define URB_ENQUEUED            (1 << 1)
 };
 
+/* Queue head, one for each active endpoint */
 struct isp1760_qh {
-        /* first part defined by EHCI spec */
+        struct list_head qh_list;
         struct list_head qtd_list;
-
         u32 toggle;
         u32 ping;
+        int slot;
+};
+
+struct urb_listitem {
+        struct list_head urb_list;
+        struct urb *urb;
 };
 
 /*
@@ -272,7 +292,7 @@ static void init_memory(struct isp1760_hcd *priv)
                 payload_addr += priv->memory_pool[curr + i].size;
         }
 
-        BUG_ON(payload_addr - priv->memory_pool[0].start > PAYLOAD_AREA_SIZE);
+        WARN_ON(payload_addr - priv->memory_pool[0].start > PAYLOAD_AREA_SIZE);
 }
 
 static void alloc_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
@@ -280,7 +300,7 @@ static void alloc_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
         int i;
 
-        BUG_ON(qtd->payload_addr);
+        WARN_ON(qtd->payload_addr);
 
         if (!qtd->length)
                 return;
@@ -293,19 +313,6 @@ static void alloc_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
                         return;
                 }
         }
-
-        dev_err(hcd->self.controller,
-                                "%s: Cannot allocate %zu bytes of memory\n"
-                                "Current memory map:\n",
-                                __func__, qtd->length);
-        for (i = 0; i < BLOCKS; i++) {
-                dev_err(hcd->self.controller, "Pool %2d size %4d status: %d\n",
-                                i, priv->memory_pool[i].size,
-                                priv->memory_pool[i].free);
-        }
-        /* XXX maybe -ENOMEM could be possible */
-        BUG();
-        return;
 }
 
 static void free_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
@@ -318,7 +325,7 @@ static void free_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
 
         for (i = 0; i < BLOCKS; i++) {
                 if (priv->memory_pool[i].start == qtd->payload_addr) {
-                        BUG_ON(priv->memory_pool[i].free);
+                        WARN_ON(priv->memory_pool[i].free);
                         priv->memory_pool[i].free = 1;
                         qtd->payload_addr = 0;
                         return;
@@ -327,19 +334,8 @@ static void free_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
 
         dev_err(hcd->self.controller, "%s: Invalid pointer: %08x\n",
                                                 __func__, qtd->payload_addr);
-        BUG();
-}
-
-static void isp1760_init_regs(struct usb_hcd *hcd)
-{
-        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG, 0);
-        reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, NO_TRANSFER_ACTIVE);
-        reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, NO_TRANSFER_ACTIVE);
-        reg_write32(hcd->regs, HC_ISO_PTD_SKIPMAP_REG, NO_TRANSFER_ACTIVE);
-
-        reg_write32(hcd->regs, HC_ATL_PTD_DONEMAP_REG, ~NO_TRANSFER_ACTIVE);
-        reg_write32(hcd->regs, HC_INT_PTD_DONEMAP_REG, ~NO_TRANSFER_ACTIVE);
-        reg_write32(hcd->regs, HC_ISO_PTD_DONEMAP_REG, ~NO_TRANSFER_ACTIVE);
+        WARN_ON(1);
+        qtd->payload_addr = 0;
 }
 
 static int handshake(struct usb_hcd *hcd, u32 reg,
@@ -377,31 +373,27 @@ static int ehci_reset(struct usb_hcd *hcd)
         return retval;
 }
 
-static void qh_destroy(struct isp1760_qh *qh)
-{
-        BUG_ON(!list_empty(&qh->qtd_list));
-        kmem_cache_free(qh_cachep, qh);
-}
-
-static struct isp1760_qh *isp1760_qh_alloc(gfp_t flags)
+static struct isp1760_qh *qh_alloc(gfp_t flags)
 {
         struct isp1760_qh *qh;
 
         qh = kmem_cache_zalloc(qh_cachep, flags);
         if (!qh)
-                return qh;
+                return NULL;
 
+        INIT_LIST_HEAD(&qh->qh_list);
         INIT_LIST_HEAD(&qh->qtd_list);
+        qh->slot = -1;
+
         return qh;
 }
 
-/* magic numbers that can affect system performance */
-#define EHCI_TUNE_CERR          3       /* 0-3 qtd retries; 0 == don't stop */
-#define EHCI_TUNE_RL_HS         4       /* nak throttle; see 4.9 */
-#define EHCI_TUNE_RL_TT         0
-#define EHCI_TUNE_MULT_HS       1       /* 1-3 transactions/uframe; 4.10.3 */
-#define EHCI_TUNE_MULT_TT       1
-#define EHCI_TUNE_FLS           2       /* (small) 256 frame schedule */
+static void qh_free(struct isp1760_qh *qh)
+{
+        WARN_ON(!list_empty(&qh->qtd_list));
+        WARN_ON(qh->slot > -1);
+        kmem_cache_free(qh_cachep, qh);
+}
 
 /* one-time init, only for memory state */
 static int priv_init(struct usb_hcd *hcd)
@@ -411,6 +403,10 @@ static int priv_init(struct usb_hcd *hcd)
 
         spin_lock_init(&priv->lock);
 
+        INIT_LIST_HEAD(&priv->interruptqhs);
+        INIT_LIST_HEAD(&priv->controlqhs);
+        INIT_LIST_HEAD(&priv->bulkqhs);
+
         /*
          * hw default: 1K periodic list heads, one per frame.
          * periodic_size can shrink by USBCMD update if hcc_params allows.
@@ -468,7 +464,10 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
         }
 
         /* pre reset */
-        isp1760_init_regs(hcd);
+        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG, 0);
+        reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, NO_TRANSFER_ACTIVE);
+        reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, NO_TRANSFER_ACTIVE);
+        reg_write32(hcd->regs, HC_ISO_PTD_SKIPMAP_REG, NO_TRANSFER_ACTIVE);
 
         /* reset */
         reg_write32(hcd->regs, HC_RESET_REG, SW_RESET_RESET_ALL);
@@ -488,12 +487,15 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
                            16 : 32, (priv->devflags & ISP1760_FLAG_ANALOG_OC) ?
                            "analog" : "digital");
 
+        /* This is weird: at the first plug-in of a device there seems to be
+           one packet queued that never gets returned? */
+        priv->active_ptds = -1;
+
         /* ATL reset */
         reg_write32(hcd->regs, HC_HW_MODE_CTRL, hwmode | ALL_ATX_RESET);
         mdelay(10);
         reg_write32(hcd->regs, HC_HW_MODE_CTRL, hwmode);
 
-        reg_write32(hcd->regs, HC_INTERRUPT_REG, INTERRUPT_ENABLE_MASK);
         reg_write32(hcd->regs, HC_INTERRUPT_ENABLE, INTERRUPT_ENABLE_MASK);
 
         /*
@@ -516,14 +518,21 @@ static void isp1760_init_maps(struct usb_hcd *hcd)
         reg_write32(hcd->regs, HC_ATL_PTD_LASTPTD_REG, 0x80000000);
         reg_write32(hcd->regs, HC_INT_PTD_LASTPTD_REG, 0x80000000);
         reg_write32(hcd->regs, HC_ISO_PTD_LASTPTD_REG, 0x00000001);
+
+        reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, 0);
+        reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, 0);
+        reg_write32(hcd->regs, HC_ISO_PTD_SKIPMAP_REG, 0);
+
+        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG,
+                                                ATL_BUF_FILL | INT_BUF_FILL);
 }
 
 static void isp1760_enable_interrupts(struct usb_hcd *hcd)
 {
         reg_write32(hcd->regs, HC_ATL_IRQ_MASK_AND_REG, 0);
-        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG, 0);
+        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG, 0xffffffff);
         reg_write32(hcd->regs, HC_INT_IRQ_MASK_AND_REG, 0);
-        reg_write32(hcd->regs, HC_INT_IRQ_MASK_OR_REG, 0);
+        reg_write32(hcd->regs, HC_INT_IRQ_MASK_OR_REG, 0xffffffff);
         reg_write32(hcd->regs, HC_ISO_IRQ_MASK_AND_REG, 0);
         reg_write32(hcd->regs, HC_ISO_IRQ_MASK_OR_REG, 0xffffffff);
         /* step 23 passed */
@@ -548,8 +557,7 @@ static int isp1760_run(struct usb_hcd *hcd)
         command |= CMD_RUN;
         reg_write32(hcd->regs, HC_USBCMD, command);
 
-        retval = handshake(hcd, HC_USBCMD, CMD_RUN, CMD_RUN,
-                        250 * 1000);
+        retval = handshake(hcd, HC_USBCMD, CMD_RUN, CMD_RUN, 250 * 1000);
         if (retval)
                 return retval;
 
@@ -598,12 +606,19 @@ static int last_qtd_of_urb(struct isp1760_qtd *qtd, struct isp1760_qh *qh)
         return (qtd->urb != urb);
 }
 
-static void transform_into_atl(struct isp1760_qh *qh,
+/* magic numbers that can affect system performance */
+#define EHCI_TUNE_CERR          3       /* 0-3 qtd retries; 0 == don't stop */
+#define EHCI_TUNE_RL_HS         4       /* nak throttle; see 4.9 */
+#define EHCI_TUNE_RL_TT         0
+#define EHCI_TUNE_MULT_HS       1       /* 1-3 transactions/uframe; 4.10.3 */
+#define EHCI_TUNE_MULT_TT       1
+#define EHCI_TUNE_FLS           2       /* (small) 256 frame schedule */
+
+static void create_ptd_atl(struct isp1760_qh *qh,
                         struct isp1760_qtd *qtd, struct ptd *ptd)
 {
         u32 maxpacket;
         u32 multi;
-        u32 pid_code;
         u32 rl = RL_COUNTER;
         u32 nak = NAK_COUNTER;
 
@@ -616,67 +631,62 @@ static void transform_into_atl(struct isp1760_qh *qh,
         maxpacket &= 0x7ff;
 
         /* DW0 */
-        ptd->dw0 = PTD_VALID;
-        ptd->dw0 |= PTD_LENGTH(qtd->length);
-        ptd->dw0 |= PTD_MAXPACKET(maxpacket);
-        ptd->dw0 |= PTD_ENDPOINT(usb_pipeendpoint(qtd->urb->pipe));
+        ptd->dw0 = DW0_VALID_BIT;
+        ptd->dw0 |= TO_DW0_LENGTH(qtd->length);
+        ptd->dw0 |= TO_DW0_MAXPACKET(maxpacket);
+        ptd->dw0 |= TO_DW0_ENDPOINT(usb_pipeendpoint(qtd->urb->pipe));
 
         /* DW1 */
         ptd->dw1 = usb_pipeendpoint(qtd->urb->pipe) >> 1;
-        ptd->dw1 |= PTD_DEVICE_ADDR(usb_pipedevice(qtd->urb->pipe));
-
-        pid_code = qtd->packet_type;
-        ptd->dw1 |= PTD_PID_TOKEN(pid_code);
+        ptd->dw1 |= TO_DW1_DEVICE_ADDR(usb_pipedevice(qtd->urb->pipe));
+        ptd->dw1 |= TO_DW1_PID_TOKEN(qtd->packet_type);
 
         if (usb_pipebulk(qtd->urb->pipe))
-                ptd->dw1 |= PTD_TRANS_BULK;
+                ptd->dw1 |= DW1_TRANS_BULK;
         else if  (usb_pipeint(qtd->urb->pipe))
-                ptd->dw1 |= PTD_TRANS_INT;
+                ptd->dw1 |= DW1_TRANS_INT;
 
         if (qtd->urb->dev->speed != USB_SPEED_HIGH) {
                 /* split transaction */
 
-                ptd->dw1 |= PTD_TRANS_SPLIT;
+                ptd->dw1 |= DW1_TRANS_SPLIT;
                 if (qtd->urb->dev->speed == USB_SPEED_LOW)
-                        ptd->dw1 |= PTD_SE_USB_LOSPEED;
+                        ptd->dw1 |= DW1_SE_USB_LOSPEED;
 
-                ptd->dw1 |= PTD_PORT_NUM(qtd->urb->dev->ttport);
-                ptd->dw1 |= PTD_HUB_NUM(qtd->urb->dev->tt->hub->devnum);
+                ptd->dw1 |= TO_DW1_PORT_NUM(qtd->urb->dev->ttport);
+                ptd->dw1 |= TO_DW1_HUB_NUM(qtd->urb->dev->tt->hub->devnum);
 
                 /* SE bit for Split INT transfers */
                 if (usb_pipeint(qtd->urb->pipe) &&
                                 (qtd->urb->dev->speed == USB_SPEED_LOW))
                         ptd->dw1 |= 2 << 16;
 
-                ptd->dw3 = 0;
                 rl = 0;
                 nak = 0;
         } else {
-                ptd->dw0 |= PTD_MULTI(multi);
+                ptd->dw0 |= TO_DW0_MULTI(multi);
                 if (usb_pipecontrol(qtd->urb->pipe) ||
                                                 usb_pipebulk(qtd->urb->pipe))
-                        ptd->dw3 = qh->ping;
-                else
-                        ptd->dw3 = 0;
+                        ptd->dw3 |= TO_DW3_PING(qh->ping);
         }
         /* DW2 */
         ptd->dw2 = 0;
-        ptd->dw2 |= PTD_DATA_START_ADDR(base_to_chip(qtd->payload_addr));
-        ptd->dw2 |= PTD_RL_CNT(rl);
-        ptd->dw3 |= PTD_NAC_CNT(nak);
+        ptd->dw2 |= TO_DW2_DATA_START_ADDR(base_to_chip(qtd->payload_addr));
+        ptd->dw2 |= TO_DW2_RL(rl);
 
         /* DW3 */
-        ptd->dw3 |= qh->toggle;
+        ptd->dw3 |= TO_DW3_NAKCOUNT(nak);
+        ptd->dw3 |= TO_DW3_DATA_TOGGLE(qh->toggle);
         if (usb_pipecontrol(qtd->urb->pipe)) {
                 if (qtd->data_buffer == qtd->urb->setup_packet)
-                        ptd->dw3 &= ~PTD_DATA_TOGGLE(1);
+                        ptd->dw3 &= ~TO_DW3_DATA_TOGGLE(1);
                 else if (last_qtd_of_urb(qtd, qh))
-                        ptd->dw3 |= PTD_DATA_TOGGLE(1);
+                        ptd->dw3 |= TO_DW3_DATA_TOGGLE(1);
         }
 
-        ptd->dw3 |= PTD_ACTIVE;
+        ptd->dw3 |= DW3_ACTIVE_BIT;
         /* Cerr */
-        ptd->dw3 |= PTD_CERR(ERR_COUNTER);
+        ptd->dw3 |= TO_DW3_CERR(ERR_COUNTER);
 }
 
 static void transform_add_int(struct isp1760_qh *qh,
@@ -731,197 +741,13 @@ static void transform_add_int(struct isp1760_qh *qh,
         ptd->dw4 = usof;
 }
 
-static void transform_into_int(struct isp1760_qh *qh,
+static void create_ptd_int(struct isp1760_qh *qh,
                         struct isp1760_qtd *qtd, struct ptd *ptd)
 {
-        transform_into_atl(qh, qtd, ptd);
+        create_ptd_atl(qh, qtd, ptd);
         transform_add_int(qh, qtd, ptd);
 }
 
-static int qtd_fill(struct isp1760_qtd *qtd, void *databuffer, size_t len,
-                u32 token)
-{
-        int count;
-
-        qtd->data_buffer = databuffer;
-        qtd->packet_type = GET_QTD_TOKEN_TYPE(token);
-
-        if (len > MAX_PAYLOAD_SIZE)
-                count = MAX_PAYLOAD_SIZE;
-        else
-                count = len;
-
-        qtd->length = count;
-        return count;
-}
-
-static int check_error(struct usb_hcd *hcd, struct ptd *ptd)
-{
-        int error = 0;
-
-        if (ptd->dw3 & DW3_HALT_BIT) {
-                error = -EPIPE;
-
-                if (ptd->dw3 & DW3_ERROR_BIT)
-                        pr_err("error bit is set in DW3\n");
-        }
-
-        if (ptd->dw3 & DW3_QTD_ACTIVE) {
-                dev_err(hcd->self.controller, "Transfer active bit is set DW3\n"
-                        "nak counter: %d, rl: %d\n",
-                        (ptd->dw3 >> 19) & 0xf, (ptd->dw2 >> 25) & 0xf);
-        }
-
-        return error;
-}
-
-static void check_int_err_status(struct usb_hcd *hcd, u32 dw4)
-{
-        u32 i;
-
-        dw4 >>= 8;
-
-        for (i = 0; i < 8; i++) {
-                switch (dw4 & 0x7) {
-                case INT_UNDERRUN:
-                        dev_err(hcd->self.controller, "Underrun (%d)\n", i);
-                        break;
-
-                case INT_EXACT:
-                        dev_err(hcd->self.controller,
-                                                "Transaction error (%d)\n", i);
-                        break;
-
-                case INT_BABBLE:
-                        dev_err(hcd->self.controller, "Babble error (%d)\n", i);
-                        break;
-                }
-                dw4 >>= 3;
-        }
-}
-
-static void enqueue_one_qtd(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
-{
-        if (qtd->length && (qtd->length <= MAX_PAYLOAD_SIZE)) {
-                switch (qtd->packet_type) {
-                case IN_PID:
-                        break;
-                case OUT_PID:
-                case SETUP_PID:
-                        mem_writes8(hcd->regs, qtd->payload_addr,
-                                                qtd->data_buffer, qtd->length);
-                }
-        }
-}
-
-static void enqueue_one_atl_qtd(struct usb_hcd *hcd, struct isp1760_qh *qh,
-                                        u32 slot, struct isp1760_qtd *qtd)
-{
-        struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        struct ptd ptd;
-
-        alloc_mem(hcd, qtd);
-        transform_into_atl(qh, qtd, &ptd);
-        ptd_write(hcd->regs, ATL_PTD_OFFSET, slot, &ptd);
-        enqueue_one_qtd(hcd, qtd);
-
-        priv->atl_ints[slot].qh = qh;
-        priv->atl_ints[slot].qtd = qtd;
-        qtd->status |= URB_ENQUEUED;
-        qtd->status |= slot << 16;
-}
-
-static void enqueue_one_int_qtd(struct usb_hcd *hcd, struct isp1760_qh *qh,
-                                        u32 slot, struct isp1760_qtd *qtd)
-{
-        struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        struct ptd ptd;
-
-        alloc_mem(hcd, qtd);
-        transform_into_int(qh, qtd, &ptd);
-        ptd_write(hcd->regs, INT_PTD_OFFSET, slot, &ptd);
-        enqueue_one_qtd(hcd, qtd);
-
-        priv->int_ints[slot].qh = qh;
-        priv->int_ints[slot].qtd = qtd;
-        qtd->status |= URB_ENQUEUED;
-        qtd->status |= slot << 16;
-}
-
-static void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
-                                  struct isp1760_qtd *qtd)
-{
-        struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        u32 skip_map, or_map;
-        u32 slot;
-        u32 buffstatus;
-
-        /*
-         * When this function is called from the interrupt handler to enqueue
-         * a follow-up packet, the SKIP register gets written and read back
-         * almost immediately. With ISP1761, this register requires a delay of
-         * 195ns between a write and subsequent read (see section 15.1.1.3).
-         */
-        mmiowb();
-        ndelay(195);
-        skip_map = reg_read32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG);
-
-        BUG_ON(!skip_map);
-        slot = __ffs(skip_map);
-
-        enqueue_one_atl_qtd(hcd, qh, slot, qtd);
-
-        or_map = reg_read32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG);
-        or_map |= (1 << slot);
-        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG, or_map);
-
-        skip_map &= ~(1 << slot);
-        reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, skip_map);
-
-        priv->atl_queued++;
-        if (priv->atl_queued == 2)
-                reg_write32(hcd->regs, HC_INTERRUPT_ENABLE,
-                                INTERRUPT_ENABLE_SOT_MASK);
-
-        buffstatus = reg_read32(hcd->regs, HC_BUFFER_STATUS_REG);
-        buffstatus |= ATL_BUFFER;
-        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG, buffstatus);
-}
-
-static void enqueue_an_INT_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
-                                  struct isp1760_qtd *qtd)
-{
-        u32 skip_map, or_map;
-        u32 slot;
-        u32 buffstatus;
-
-        /*
-         * When this function is called from the interrupt handler to enqueue
-         * a follow-up packet, the SKIP register gets written and read back
-         * almost immediately. With ISP1761, this register requires a delay of
-         * 195ns between a write and subsequent read (see section 15.1.1.3).
-         */
-        mmiowb();
-        ndelay(195);
-        skip_map = reg_read32(hcd->regs, HC_INT_PTD_SKIPMAP_REG);
-
-        BUG_ON(!skip_map);
-        slot = __ffs(skip_map);
-
-        enqueue_one_int_qtd(hcd, qh, slot, qtd);
-
-        or_map = reg_read32(hcd->regs, HC_INT_IRQ_MASK_OR_REG);
-        or_map |= (1 << slot);
-        reg_write32(hcd->regs, HC_INT_IRQ_MASK_OR_REG, or_map);
-
-        skip_map &= ~(1 << slot);
-        reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, skip_map);
-
-        buffstatus = reg_read32(hcd->regs, HC_BUFFER_STATUS_REG);
-        buffstatus |= INT_BUFFER;
-        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG, buffstatus);
-}
-
 static void isp1760_urb_done(struct usb_hcd *hcd, struct urb *urb)
 __releases(priv->lock)
 __acquires(priv->lock)
@@ -948,557 +774,620 @@ __acquires(priv->lock)
         spin_lock(&priv->lock);
 }
 
-static void isp1760_qtd_free(struct isp1760_qtd *qtd)
+static struct isp1760_qtd *qtd_alloc(gfp_t flags, struct urb *urb,
+                                                                u8 packet_type)
 {
-        BUG_ON(qtd->payload_addr);
-        kmem_cache_free(qtd_cachep, qtd);
-}
+        struct isp1760_qtd *qtd;
 
-static struct isp1760_qtd *clean_this_qtd(struct isp1760_qtd *qtd,
-                                                        struct isp1760_qh *qh)
-{
-        struct isp1760_qtd *tmp_qtd;
+        qtd = kmem_cache_zalloc(qtd_cachep, flags);
+        if (!qtd)
+                return NULL;
 
-        if (list_is_last(&qtd->qtd_list, &qh->qtd_list))
-                tmp_qtd = NULL;
-        else
-                tmp_qtd = list_entry(qtd->qtd_list.next, struct isp1760_qtd,
-                                                                qtd_list);
-        list_del(&qtd->qtd_list);
-        isp1760_qtd_free(qtd);
-        return tmp_qtd;
+        INIT_LIST_HEAD(&qtd->qtd_list);
+        qtd->urb = urb;
+        qtd->packet_type = packet_type;
+        qtd->status = QTD_ENQUEUED;
+        qtd->actual_length = 0;
+
+        return qtd;
 }
 
-/*
- * Remove this QTD from the QH list and free its memory. If this QTD
- * isn't the last one than remove also his successor(s).
- * Returns the QTD which is part of an new URB and should be enqueued.
- */
-static struct isp1760_qtd *clean_up_qtdlist(struct isp1760_qtd *qtd,
-                                                        struct isp1760_qh *qh)
+static void qtd_free(struct isp1760_qtd *qtd)
 {
-        struct urb *urb;
-
-        urb = qtd->urb;
-        do {
-                qtd = clean_this_qtd(qtd, qh);
-        } while (qtd && (qtd->urb == urb));
-
-        return qtd;
+        WARN_ON(qtd->payload_addr);
+        kmem_cache_free(qtd_cachep, qtd);
 }
 
-static void do_atl_int(struct usb_hcd *hcd)
+static void start_bus_transfer(struct usb_hcd *hcd, u32 ptd_offset, int slot,
+                                struct slotinfo *slots, struct isp1760_qtd *qtd,
+                                struct isp1760_qh *qh, struct ptd *ptd)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        u32 done_map, skip_map;
-        struct ptd ptd;
-        struct urb *urb;
-        u32 slot;
-        u32 length;
-        u32 or_map;
-        u32 status = -EINVAL;
-        int error;
-        struct isp1760_qtd *qtd;
-        struct isp1760_qh *qh;
-        u32 rl;
-        u32 nakcount;
-
-        done_map = reg_read32(hcd->regs, HC_ATL_PTD_DONEMAP_REG);
-        skip_map = reg_read32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG);
+        WARN_ON((slot < 0) || (slot > 31));
+        WARN_ON(qtd->length && !qtd->payload_addr);
+        WARN_ON(slots[slot].qtd);
+        WARN_ON(slots[slot].qh);
+        WARN_ON(qtd->status != QTD_PAYLOAD_ALLOC);
+
+        slots[slot].qtd = qtd;
+        slots[slot].qh = qh;
+        qh->slot = slot;
+        qtd->status = QTD_XFER_STARTED; /* Set this before writing ptd, since
+                interrupt routine may preempt and expects this value. */
+        ptd_write(hcd->regs, ptd_offset, slot, ptd);
+        priv->active_ptds++;
+}
 
-        or_map = reg_read32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG);
-        or_map &= ~done_map;
-        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG, or_map);
+static int is_short_bulk(struct isp1760_qtd *qtd)
+{
+        return (usb_pipebulk(qtd->urb->pipe) &&
+                                        (qtd->actual_length < qtd->length));
+}
 
-        while (done_map) {
-                status = 0;
-                priv->atl_queued--;
+static void collect_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh,
+                                                struct list_head *urb_list)
+{
+        int last_qtd;
+        struct isp1760_qtd *qtd, *qtd_next;
+        struct urb_listitem *urb_listitem;
 
-                slot = __ffs(done_map);
-                done_map &= ~(1 << slot);
-                skip_map |= (1 << slot);
+        list_for_each_entry_safe(qtd, qtd_next, &qh->qtd_list, qtd_list) {
+                if (qtd->status < QTD_XFER_COMPLETE)
+                        break;
 
-                qtd = priv->atl_ints[slot].qtd;
-                qh = priv->atl_ints[slot].qh;
+                if (list_is_last(&qtd->qtd_list, &qh->qtd_list))
+                        last_qtd = 1;
+                else
+                        last_qtd = qtd->urb != qtd_next->urb;
+
+                if ((!last_qtd) && (qtd->status == QTD_RETIRE))
+                        qtd_next->status = QTD_RETIRE;
+
+                if (qtd->status == QTD_XFER_COMPLETE) {
+                        if (qtd->actual_length) {
+                                switch (qtd->packet_type) {
+                                case IN_PID:
+                                        mem_reads8(hcd->regs, qtd->payload_addr,
+                                                        qtd->data_buffer,
+                                                        qtd->actual_length);
+                                        /* Fall through (?) */
+                                case OUT_PID:
+                                        qtd->urb->actual_length +=
+                                                        qtd->actual_length;
+                                        /* Fall through ... */
+                                case SETUP_PID:
+                                        break;
+                                }
+                        }
 
-                if (!qh) {
-                        dev_err(hcd->self.controller, "qh is 0\n");
-                        continue;
+                        if (is_short_bulk(qtd)) {
+                                if (qtd->urb->transfer_flags & URB_SHORT_NOT_OK)
+                                        qtd->urb->status = -EREMOTEIO;
+                                if (!last_qtd)
+                                        qtd_next->status = QTD_RETIRE;
+                        }
                 }
-                ptd_read(hcd->regs, ATL_PTD_OFFSET, slot, &ptd);
-
-                rl = (ptd.dw2 >> 25) & 0x0f;
-                nakcount = (ptd.dw3 >> 19) & 0xf;
 
-                /* Transfer Error, *but* active and no HALT -> reload */
-                if ((ptd.dw3 & DW3_ERROR_BIT) && (ptd.dw3 & DW3_QTD_ACTIVE) &&
-                                !(ptd.dw3 & DW3_HALT_BIT)) {
-
-                        /* according to ppriv code, we have to
-                         * reload this one if trasfered bytes != requested bytes
-                         * else act like everything went smooth..
-                         * XXX This just doesn't feel right and hasn't
-                         * triggered so far.
-                         */
+                if (qtd->payload_addr)
+                        free_mem(hcd, qtd);
 
-                        length = PTD_XFERRED_LENGTH(ptd.dw3);
-                        dev_err(hcd->self.controller,
-                                        "Should reload now... transferred %d "
-                                        "of %zu\n", length, qtd->length);
-                        BUG();
+                if (last_qtd) {
+                        if ((qtd->status == QTD_RETIRE) &&
+                                        (qtd->urb->status == -EINPROGRESS))
+                                qtd->urb->status = -EPIPE;
+                        /* Defer calling of urb_done() since it releases lock */
+                        urb_listitem = kmem_cache_zalloc(urb_listitem_cachep,
+                                                                GFP_ATOMIC);
+                        if (unlikely(!urb_listitem))
+                                break;
+                        urb_listitem->urb = qtd->urb;
+                        list_add_tail(&urb_listitem->urb_list, urb_list);
                 }
 
-                if (!nakcount && (ptd.dw3 & DW3_QTD_ACTIVE)) {
-                        u32 buffstatus;
+                list_del(&qtd->qtd_list);
+                qtd_free(qtd);
+        }
+}
 
-                        /*
-                         * NAKs are handled in HW by the chip. Usually if the
-                         * device is not able to send data fast enough.
-                         * This happens mostly on slower hardware.
-                         */
+#define ENQUEUE_DEPTH   2
+static void enqueue_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        int ptd_offset;
+        struct slotinfo *slots;
+        int curr_slot, free_slot;
+        int n;
+        struct ptd ptd;
+        struct isp1760_qtd *qtd;
 
-                        /* RL counter = ERR counter */
-                        ptd.dw3 &= ~(0xf << 19);
-                        ptd.dw3 |= rl << 19;
-                        ptd.dw3 &= ~(3 << (55 - 32));
-                        ptd.dw3 |= ERR_COUNTER << (55 - 32);
-
-                        /*
-                         * It is not needed to write skip map back because it
-                         * is unchanged. Just make sure that this entry is
-                         * unskipped once it gets written to the HW.
-                         */
-                        skip_map &= ~(1 << slot);
-                        or_map = reg_read32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG);
-                        or_map |= 1 << slot;
-                        reg_write32(hcd->regs, HC_ATL_IRQ_MASK_OR_REG, or_map);
+        if (unlikely(list_empty(&qh->qtd_list))) {
+                WARN_ON(1);
+                return;
+        }
 
-                        ptd.dw0 |= PTD_VALID;
-                        ptd_write(hcd->regs, ATL_PTD_OFFSET, slot, &ptd);
+        if (usb_pipeint(list_entry(qh->qtd_list.next, struct isp1760_qtd,
+                                                        qtd_list)->urb->pipe)) {
+                ptd_offset = INT_PTD_OFFSET;
+                slots = priv->int_slots;
+        } else {
+                ptd_offset = ATL_PTD_OFFSET;
+                slots = priv->atl_slots;
+        }
 
-                        priv->atl_queued++;
-                        if (priv->atl_queued == 2)
-                                reg_write32(hcd->regs, HC_INTERRUPT_ENABLE,
-                                                INTERRUPT_ENABLE_SOT_MASK);
+        free_slot = -1;
+        for (curr_slot = 0; curr_slot < 32; curr_slot++) {
+                if ((free_slot == -1) && (slots[curr_slot].qtd == NULL))
+                        free_slot = curr_slot;
+                if (slots[curr_slot].qh == qh)
+                        break;
+        }
 
-                        buffstatus = reg_read32(hcd->regs,
-                                                        HC_BUFFER_STATUS_REG);
-                        buffstatus |= ATL_BUFFER;
-                        reg_write32(hcd->regs, HC_BUFFER_STATUS_REG,
-                                                                buffstatus);
-                        continue;
-                }
+        n = 0;
+        list_for_each_entry(qtd, &qh->qtd_list, qtd_list) {
+                if (qtd->status == QTD_ENQUEUED) {
+                        WARN_ON(qtd->payload_addr);
+                        alloc_mem(hcd, qtd);
+                        if ((qtd->length) && (!qtd->payload_addr))
+                                break;
 
-                error = check_error(hcd, &ptd);
-                if (error) {
-                        status = error;
-                        priv->atl_ints[slot].qh->toggle = 0;
-                        priv->atl_ints[slot].qh->ping = 0;
-                        qtd->urb->status = -EPIPE;
-
-#if 0
-                        printk(KERN_ERR "Error in %s().\n", __func__);
-                        printk(KERN_ERR "IN dw0: %08x dw1: %08x dw2: %08x "
-                                        "dw3: %08x dw4: %08x dw5: %08x dw6: "
-                                        "%08x dw7: %08x\n",
-                                        ptd.dw0, ptd.dw1, ptd.dw2, ptd.dw3,
-                                        ptd.dw4, ptd.dw5, ptd.dw6, ptd.dw7);
-#endif
-                } else {
-                        priv->atl_ints[slot].qh->toggle = ptd.dw3 & (1 << 25);
-                        priv->atl_ints[slot].qh->ping = ptd.dw3 & (1 << 26);
+                        if ((qtd->length) &&
+                            ((qtd->packet_type == SETUP_PID) ||
+                             (qtd->packet_type == OUT_PID))) {
+                                mem_writes8(hcd->regs, qtd->payload_addr,
+                                                qtd->data_buffer, qtd->length);
+                        }
+
+                        qtd->status = QTD_PAYLOAD_ALLOC;
                 }
 
-                length = PTD_XFERRED_LENGTH(ptd.dw3);
-                if (length) {
-                        switch (DW1_GET_PID(ptd.dw1)) {
-                        case IN_PID:
-                                mem_reads8(hcd->regs, qtd->payload_addr,
-                                                qtd->data_buffer, length);
+                if (qtd->status == QTD_PAYLOAD_ALLOC) {
+/*
+                        if ((curr_slot > 31) && (free_slot == -1))
+                                dev_dbg(hcd->self.controller, "%s: No slot "
+                                        "available for transfer\n", __func__);
+*/
+                        /* Start xfer for this endpoint if not already done */
+                        if ((curr_slot > 31) && (free_slot > -1)) {
+                                if (usb_pipeint(qtd->urb->pipe))
+                                        create_ptd_int(qh, qtd, &ptd);
+                                else
+                                        create_ptd_atl(qh, qtd, &ptd);
+
+                                start_bus_transfer(hcd, ptd_offset, free_slot,
+                                                        slots, qtd, qh, &ptd);
+                                curr_slot = free_slot;
+                        }
 
-                        case OUT_PID:
+                        n++;
+                        if (n >= ENQUEUE_DEPTH)
+                                break;
+                }
+        }
+}
 
-                                qtd->urb->actual_length += length;
+void schedule_ptds(struct usb_hcd *hcd)
+{
+        struct isp1760_hcd *priv;
+        struct isp1760_qh *qh, *qh_next;
+        struct list_head *ep_queue;
+        struct usb_host_endpoint *ep;
+        LIST_HEAD(urb_list);
+        struct urb_listitem *urb_listitem, *urb_listitem_next;
+
+        if (!hcd) {
+                WARN_ON(1);
+                return;
+        }
 
-                        case SETUP_PID:
-                                break;
+        priv = hcd_to_priv(hcd);
+
+        /*
+         * check finished/retired xfers, transfer payloads, call urb_done()
+         */
+        ep_queue = &priv->interruptqhs;
+        while (ep_queue) {
+                list_for_each_entry_safe(qh, qh_next, ep_queue, qh_list) {
+                        ep = list_entry(qh->qtd_list.next, struct isp1760_qtd,
+                                                        qtd_list)->urb->ep;
+                        collect_qtds(hcd, qh, &urb_list);
+                        if (list_empty(&qh->qtd_list)) {
+                                list_del(&qh->qh_list);
+                                if (ep->hcpriv == NULL) {
+                                        /* Endpoint has been disabled, so we
+                                        can free the associated queue head. */
+                                        qh_free(qh);
+                                }
                         }
                 }
 
-                priv->atl_ints[slot].qtd = NULL;
-                priv->atl_ints[slot].qh = NULL;
-
-                free_mem(hcd, qtd);
+                if (ep_queue == &priv->interruptqhs)
+                        ep_queue = &priv->controlqhs;
+                else if (ep_queue == &priv->controlqhs)
+                        ep_queue = &priv->bulkqhs;
+                else
+                        ep_queue = NULL;
+        }
 
-                reg_write32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG, skip_map);
+        list_for_each_entry_safe(urb_listitem, urb_listitem_next, &urb_list,
+                                                                urb_list) {
+                isp1760_urb_done(hcd, urb_listitem->urb);
+                kmem_cache_free(urb_listitem_cachep, urb_listitem);
+        }
 
-                if (qtd->urb->status == -EPIPE) {
-                        /* HALT was received */
+        /*
+         * Schedule packets for transfer.
+         *
+         * According to USB2.0 specification:
+         *
+         * 1st prio: interrupt xfers, up to 80 % of bandwidth
+         * 2nd prio: control xfers
+         * 3rd prio: bulk xfers
+         *
+         * ... but let's use a simpler scheme here (mostly because ISP1761 doc
+         * is very unclear on how to prioritize traffic):
+         *
+         * 1) Enqueue any queued control transfers, as long as payload chip mem
+         *    and PTD ATL slots are available.
+         * 2) Enqueue any queued INT transfers, as long as payload chip mem
+         *    and PTD INT slots are available.
+         * 3) Enqueue any queued bulk transfers, as long as payload chip mem
+         *    and PTD ATL slots are available.
+         *
+         * Use double buffering (ENQUEUE_DEPTH==2) as a compromise between
+         * conservation of chip mem and performance.
+         *
+         * I'm sure this scheme could be improved upon!
+         */
+        ep_queue = &priv->controlqhs;
+        while (ep_queue) {
+                list_for_each_entry_safe(qh, qh_next, ep_queue, qh_list)
+                        enqueue_qtds(hcd, qh);
+
+                if (ep_queue == &priv->controlqhs)
+                        ep_queue = &priv->interruptqhs;
+                else if (ep_queue == &priv->interruptqhs)
+                        ep_queue = &priv->bulkqhs;
+                else
+                        ep_queue = NULL;
+        }
+}
 
-                        urb = qtd->urb;
-                        qtd = clean_up_qtdlist(qtd, qh);
-                        isp1760_urb_done(hcd, urb);
+#define PTD_STATE_QTD_DONE      1
+#define PTD_STATE_QTD_RELOAD    2
+#define PTD_STATE_URB_RETIRE    3
 
-                } else if (usb_pipebulk(qtd->urb->pipe) &&
-                                                (length < qtd->length)) {
-                        /* short BULK received */
+static int check_int_transfer(struct usb_hcd *hcd, struct ptd *ptd,
+                                                                struct urb *urb)
+{
+        __dw dw4;
+        int i;
 
-                        if (qtd->urb->transfer_flags & URB_SHORT_NOT_OK) {
-                                qtd->urb->status = -EREMOTEIO;
-                                dev_dbg(hcd->self.controller,
-                                                "short bulk, %d instead %zu "
-                                                "with URB_SHORT_NOT_OK flag.\n",
-                                                length, qtd->length);
-                        }
+        dw4 = ptd->dw4;
+        dw4 >>= 8;
 
-                        if (qtd->urb->status == -EINPROGRESS)
-                                qtd->urb->status = 0;
+        /* FIXME: ISP1761 datasheet does not say what to do with these. Do we
+           need to handle these errors? Is it done in hardware? */
 
-                        urb = qtd->urb;
-                        qtd = clean_up_qtdlist(qtd, qh);
-                        isp1760_urb_done(hcd, urb);
+        if (ptd->dw3 & DW3_HALT_BIT) {
 
-                } else if (last_qtd_of_urb(qtd, qh)) {
-                        /* that was the last qtd of that URB */
+                urb->status = -EPROTO; /* Default unknown error */
 
-                        if (qtd->urb->status == -EINPROGRESS)
-                                qtd->urb->status = 0;
+                for (i = 0; i < 8; i++) {
+                        switch (dw4 & 0x7) {
+                        case INT_UNDERRUN:
+                                dev_dbg(hcd->self.controller, "%s: underrun "
+                                                "during uFrame %d\n",
+                                                __func__, i);
+                                urb->status = -ECOMM; /* Could not write data */
+                                break;
+                        case INT_EXACT:
+                                dev_dbg(hcd->self.controller, "%s: transaction "
+                                                "error during uFrame %d\n",
+                                                __func__, i);
+                                urb->status = -EPROTO; /* timeout, bad CRC, PID
+                                                          error etc. */
+                                break;
+                        case INT_BABBLE:
+                                dev_dbg(hcd->self.controller, "%s: babble "
+                                                "error during uFrame %d\n",
+                                                __func__, i);
+                                urb->status = -EOVERFLOW;
+                                break;
+                        }
+                        dw4 >>= 3;
+                }
 
-                        urb = qtd->urb;
-                        qtd = clean_up_qtdlist(qtd, qh);
-                        isp1760_urb_done(hcd, urb);
+                return PTD_STATE_URB_RETIRE;
+        }
 
-                } else {
-                        /* next QTD of this URB */
+        return PTD_STATE_QTD_DONE;
+}
 
-                        qtd = clean_this_qtd(qtd, qh);
-                        BUG_ON(!qtd);
-                }
+static int check_atl_transfer(struct usb_hcd *hcd, struct ptd *ptd,
+                                                                struct urb *urb)
+{
+        WARN_ON(!ptd);
+        if (ptd->dw3 & DW3_HALT_BIT) {
+                if (ptd->dw3 & DW3_BABBLE_BIT)
+                        urb->status = -EOVERFLOW;
+                else if (FROM_DW3_CERR(ptd->dw3))
+                        urb->status = -EPIPE;  /* Stall */
+                else if (ptd->dw3 & DW3_ERROR_BIT)
+                        urb->status = -EPROTO; /* XactErr */
+                else
+                        urb->status = -EPROTO; /* Unknown */
+/*
+                dev_dbg(hcd->self.controller, "%s: ptd error:\n"
+                        "        dw0: %08x dw1: %08x dw2: %08x dw3: %08x\n"
+                        "        dw4: %08x dw5: %08x dw6: %08x dw7: %08x\n",
+                        __func__,
+                        ptd->dw0, ptd->dw1, ptd->dw2, ptd->dw3,
+                        ptd->dw4, ptd->dw5, ptd->dw6, ptd->dw7);
+*/
+                return PTD_STATE_URB_RETIRE;
+        }
 
-                if (qtd)
-                        enqueue_an_ATL_packet(hcd, qh, qtd);
+        if ((ptd->dw3 & DW3_ERROR_BIT) && (ptd->dw3 & DW3_ACTIVE_BIT)) {
+                /* Transfer Error, *but* active and no HALT -> reload */
+                dev_dbg(hcd->self.controller, "PID error; reloading ptd\n");
+                return PTD_STATE_QTD_RELOAD;
+        }
 
-                skip_map = reg_read32(hcd->regs, HC_ATL_PTD_SKIPMAP_REG);
+        if (!FROM_DW3_NAKCOUNT(ptd->dw3) && (ptd->dw3 & DW3_ACTIVE_BIT)) {
+                /*
+                 * NAKs are handled in HW by the chip. Usually if the
+                 * device is not able to send data fast enough.
+                 * This happens mostly on slower hardware.
+                 */
+                return PTD_STATE_QTD_RELOAD;
         }
-        if (priv->atl_queued <= 1)
-                reg_write32(hcd->regs, HC_INTERRUPT_ENABLE,
-                                                        INTERRUPT_ENABLE_MASK);
+
+        return PTD_STATE_QTD_DONE;
 }
 
-static void do_intl_int(struct usb_hcd *hcd)
+static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        u32 done_map, skip_map;
+        u32 imask;
+        irqreturn_t irqret = IRQ_NONE;
         struct ptd ptd;
-        struct urb *urb;
-        u32 length;
-        u32 or_map;
-        int error;
-        u32 slot;
-        struct isp1760_qtd *qtd;
         struct isp1760_qh *qh;
+        int int_done_map, atl_done_map;
+        int slot;
+        int state;
+        struct slotinfo *slots;
+        u32 ptd_offset;
+        struct isp1760_qtd *qtd;
+        int modified;
+        static int last_active_ptds;
 
-        done_map = reg_read32(hcd->regs, HC_INT_PTD_DONEMAP_REG);
-        skip_map = reg_read32(hcd->regs, HC_INT_PTD_SKIPMAP_REG);
-
-        or_map = reg_read32(hcd->regs, HC_INT_IRQ_MASK_OR_REG);
-        or_map &= ~done_map;
-        reg_write32(hcd->regs, HC_INT_IRQ_MASK_OR_REG, or_map);
-
-        while (done_map) {
-                slot = __ffs(done_map);
-                done_map &= ~(1 << slot);
-                skip_map |= (1 << slot);
-
-                qtd = priv->int_ints[slot].qtd;
-                qh = priv->int_ints[slot].qh;
-
-                if (!qh) {
-                        dev_err(hcd->self.controller, "(INT) qh is 0\n");
-                        continue;
-                }
+        spin_lock(&priv->lock);
 
-                ptd_read(hcd->regs, INT_PTD_OFFSET, slot, &ptd);
-                check_int_err_status(hcd, ptd.dw4);
-
-                error = check_error(hcd, &ptd);
-                if (error) {
-#if 0
-                        printk(KERN_ERR "Error in %s().\n", __func__);
-                        printk(KERN_ERR "IN dw0: %08x dw1: %08x dw2: %08x "
-                                        "dw3: %08x dw4: %08x dw5: %08x dw6: "
-                                        "%08x dw7: %08x\n",
-                                        ptd.dw0, ptd.dw1, ptd.dw2, ptd.dw3,
-                                        ptd.dw4, ptd.dw5, ptd.dw6, ptd.dw7);
-#endif
-                        qtd->urb->status = -EPIPE;
-                        priv->int_ints[slot].qh->toggle = 0;
-                        priv->int_ints[slot].qh->ping = 0;
+        if (!(hcd->state & HC_STATE_RUNNING))
+                goto leave;
 
+        imask = reg_read32(hcd->regs, HC_INTERRUPT_REG);
+        if (unlikely(!imask))
+                goto leave;
+        reg_write32(hcd->regs, HC_INTERRUPT_REG, imask); /* Clear */
+
+        int_done_map = reg_read32(hcd->regs, HC_INT_PTD_DONEMAP_REG);
+        atl_done_map = reg_read32(hcd->regs, HC_ATL_PTD_DONEMAP_REG);
+        modified = int_done_map | atl_done_map;
+
+        while (int_done_map || atl_done_map) {
+                if (int_done_map) {
+                        /* INT ptd */
+                        slot = __ffs(int_done_map);
+                        int_done_map &= ~(1 << slot);
+                        slots = priv->int_slots;
+                        if (!slots[slot].qh)
+                                continue;
+                        ptd_offset = INT_PTD_OFFSET;
+                        ptd_read(hcd->regs, INT_PTD_OFFSET, slot, &ptd);
+                        state = check_int_transfer(hcd, &ptd,
+                                                        slots[slot].qtd->urb);
                 } else {
-                        priv->int_ints[slot].qh->toggle = ptd.dw3 & (1 << 25);
-                        priv->int_ints[slot].qh->ping = ptd.dw3 & (1 << 26);
+                        /* ATL ptd */
+                        slot = __ffs(atl_done_map);
+                        atl_done_map &= ~(1 << slot);
+                        slots = priv->atl_slots;
+                        if (!slots[slot].qh)
+                                continue;
+                        ptd_offset = ATL_PTD_OFFSET;
+                        ptd_read(hcd->regs, ATL_PTD_OFFSET, slot, &ptd);
+                        state = check_atl_transfer(hcd, &ptd,
+                                                        slots[slot].qtd->urb);
                 }
 
-                if (qtd->urb->dev->speed != USB_SPEED_HIGH)
-                        length = PTD_XFERRED_LENGTH_LO(ptd.dw3);
-                else
-                        length = PTD_XFERRED_LENGTH(ptd.dw3);
+                qtd = slots[slot].qtd;
+                slots[slot].qtd = NULL;
+                qh = slots[slot].qh;
+                slots[slot].qh = NULL;
+                priv->active_ptds--;
+                qh->slot = -1;
+
+                WARN_ON(qtd->status != QTD_XFER_STARTED);
+
+                switch (state) {
+                case PTD_STATE_QTD_DONE:
+                        if ((usb_pipeint(qtd->urb->pipe)) &&
+                                       (qtd->urb->dev->speed != USB_SPEED_HIGH))
+                                qtd->actual_length =
+                                       FROM_DW3_SCS_NRBYTESTRANSFERRED(ptd.dw3);
+                        else
+                                qtd->actual_length =
+                                        FROM_DW3_NRBYTESTRANSFERRED(ptd.dw3);
+
+                        qtd->status = QTD_XFER_COMPLETE;
+                        if (list_is_last(&qtd->qtd_list, &qh->qtd_list) ||
+                                                        is_short_bulk(qtd))
+                                qtd = NULL;
+                        else
+                                qtd = list_entry(qtd->qtd_list.next,
+                                                        typeof(*qtd), qtd_list);
+
+                        qh->toggle = FROM_DW3_DATA_TOGGLE(ptd.dw3);
+                        qh->ping = FROM_DW3_PING(ptd.dw3);
+                        break;
 
-                if (length) {
-                        switch (DW1_GET_PID(ptd.dw1)) {
-                        case IN_PID:
-                                mem_reads8(hcd->regs, qtd->payload_addr,
-                                                qtd->data_buffer, length);
-                        case OUT_PID:
+                case PTD_STATE_QTD_RELOAD: /* QTD_RETRY, for atls only */
+                        qtd->status = QTD_PAYLOAD_ALLOC;
+                        ptd.dw0 |= DW0_VALID_BIT;
+                        /* RL counter = ERR counter */
+                        ptd.dw3 &= ~TO_DW3_NAKCOUNT(0xf);
+                        ptd.dw3 |= TO_DW3_NAKCOUNT(FROM_DW2_RL(ptd.dw2));
+                        ptd.dw3 &= ~TO_DW3_CERR(3);
+                        ptd.dw3 |= TO_DW3_CERR(ERR_COUNTER);
+                        qh->toggle = FROM_DW3_DATA_TOGGLE(ptd.dw3);
+                        qh->ping = FROM_DW3_PING(ptd.dw3);
+                        break;
 
-                                qtd->urb->actual_length += length;
+                case PTD_STATE_URB_RETIRE:
+                        qtd->status = QTD_RETIRE;
+                        qtd = NULL;
+                        qh->toggle = 0;
+                        qh->ping = 0;
+                        break;
 
-                        case SETUP_PID:
-                                break;
-                        }
+                default:
+                        WARN_ON(1);
+                        continue;
                 }
 
-                priv->int_ints[slot].qtd = NULL;
-                priv->int_ints[slot].qh = NULL;
-
-                reg_write32(hcd->regs, HC_INT_PTD_SKIPMAP_REG, skip_map);
-                free_mem(hcd, qtd);
-
-                if (qtd->urb->status == -EPIPE) {
-                        /* HALT received */
-
-                        urb = qtd->urb;
-                        qtd = clean_up_qtdlist(qtd, qh);
-                        isp1760_urb_done(hcd, urb);
-
-                } else if (last_qtd_of_urb(qtd, qh)) {
-
-                        if (qtd->urb->status == -EINPROGRESS)
-                                qtd->urb->status = 0;
-
-                        urb = qtd->urb;
-                        qtd = clean_up_qtdlist(qtd, qh);
-                        isp1760_urb_done(hcd, urb);
-
-                } else {
-                        /* next QTD of this URB */
+                if (qtd && (qtd->status == QTD_PAYLOAD_ALLOC)) {
+                        if (slots == priv->int_slots) {
+                                if (state == PTD_STATE_QTD_RELOAD)
+                                        dev_err(hcd->self.controller,
+                                                "%s: PTD_STATE_QTD_RELOAD on "
+                                                "interrupt packet\n", __func__);
+                                if (state != PTD_STATE_QTD_RELOAD)
+                                        create_ptd_int(qh, qtd, &ptd);
+                        } else {
+                                if (state != PTD_STATE_QTD_RELOAD)
+                                        create_ptd_atl(qh, qtd, &ptd);
+                        }
 
-                        qtd = clean_this_qtd(qtd, qh);
-                        BUG_ON(!qtd);
+                        start_bus_transfer(hcd, ptd_offset, slot, slots, qtd,
+                                qh, &ptd);
                 }
-
-                if (qtd)
-                        enqueue_an_INT_packet(hcd, qh, qtd);
-
-                skip_map = reg_read32(hcd->regs, HC_INT_PTD_SKIPMAP_REG);
         }
-}
-
-static struct isp1760_qh *qh_make(struct usb_hcd *hcd, struct urb *urb,
-                gfp_t flags)
-{
-        struct isp1760_qh *qh;
-        int is_input, type;
-
-        qh = isp1760_qh_alloc(flags);
-        if (!qh)
-                return qh;
-
-        /*
-         * init endpoint/device data for this QH
-         */
-        is_input = usb_pipein(urb->pipe);
-        type = usb_pipetype(urb->pipe);
 
-        if (!usb_pipecontrol(urb->pipe))
-                usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), !is_input,
-                                1);
-        return qh;
-}
+        if (modified)
+                schedule_ptds(hcd);
 
-/*
- * For control/bulk/interrupt, return QH with these TDs appended.
- * Allocates and initializes the QH if necessary.
- * Returns null if it can't allocate a QH it needs to.
- * If the QH has TDs (urbs) already, that's great.
- */
-static struct isp1760_qh *qh_append_tds(struct usb_hcd *hcd,
-                struct urb *urb, struct list_head *qtd_list, int epnum,
-                void **ptr)
-{
-        struct isp1760_qh *qh;
+        /* ISP1760 Errata 2 explains that interrupts may be missed (or not
+           happen?) if two USB devices are running simultaneously. Perhaps
+           this happens when a PTD is finished during interrupt handling;
+           enable SOF interrupts if PTDs are still scheduled when exiting this
+           interrupt handler, just to be safe. */
 
-        qh = (struct isp1760_qh *)*ptr;
-        if (!qh) {
-                /* can't sleep here, we have priv->lock... */
-                qh = qh_make(hcd, urb, GFP_ATOMIC);
-                if (!qh)
-                        return qh;
-                *ptr = qh;
+        if (priv->active_ptds != last_active_ptds) {
+                if (priv->active_ptds > 0)
+                        reg_write32(hcd->regs, HC_INTERRUPT_ENABLE,
+                                                INTERRUPT_ENABLE_SOT_MASK);
+                else
+                        reg_write32(hcd->regs, HC_INTERRUPT_ENABLE,
+                                                INTERRUPT_ENABLE_MASK);
+                last_active_ptds = priv->active_ptds;
         }
 
-        list_splice(qtd_list, qh->qtd_list.prev);
+        irqret = IRQ_HANDLED;
+leave:
+        spin_unlock(&priv->lock);
 
-        return qh;
+        return irqret;
 }
 
-static void qtd_list_free(struct urb *urb, struct list_head *qtd_list)
+static int qtd_fill(struct isp1760_qtd *qtd, void *databuffer, size_t len)
 {
-        struct list_head *entry, *temp;
+        qtd->data_buffer = databuffer;
 
-        list_for_each_safe(entry, temp, qtd_list) {
-                struct isp1760_qtd      *qtd;
+        if (len > MAX_PAYLOAD_SIZE)
+                len = MAX_PAYLOAD_SIZE;
+        qtd->length = len;
 
-                qtd = list_entry(entry, struct isp1760_qtd, qtd_list);
-                list_del(&qtd->qtd_list);
-                isp1760_qtd_free(qtd);
-        }
+        return qtd->length;
 }
 
-static int isp1760_prepare_enqueue(struct usb_hcd *hcd, struct urb *urb,
-                struct list_head *qtd_list, gfp_t mem_flags, packet_enqueue *p)
+static void qtd_list_free(struct list_head *qtd_list)
 {
-        struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        struct isp1760_qtd         *qtd;
-        int                     epnum;
-        unsigned long           flags;
-        struct isp1760_qh          *qh = NULL;
-        int                     rc;
-        int qh_busy;
+        struct isp1760_qtd *qtd, *qtd_next;
 
-        qtd = list_entry(qtd_list->next, struct isp1760_qtd, qtd_list);
-        epnum = urb->ep->desc.bEndpointAddress;
-
-        spin_lock_irqsave(&priv->lock, flags);
-        if (!HCD_HW_ACCESSIBLE(hcd)) {
-                rc = -ESHUTDOWN;
-                goto done;
-        }
-        rc = usb_hcd_link_urb_to_ep(hcd, urb);
-        if (rc)
-                goto done;
-
-        qh = urb->ep->hcpriv;
-        if (qh)
-                qh_busy = !list_empty(&qh->qtd_list);
-        else
-                qh_busy = 0;
-
-        qh = qh_append_tds(hcd, urb, qtd_list, epnum, &urb->ep->hcpriv);
-        if (!qh) {
-                usb_hcd_unlink_urb_from_ep(hcd, urb);
-                rc = -ENOMEM;
-                goto done;
+        list_for_each_entry_safe(qtd, qtd_next, qtd_list, qtd_list) {
+                list_del(&qtd->qtd_list);
+                qtd_free(qtd);
         }
-
-        if (!qh_busy)
-                p(hcd, qh, qtd);
-
-done:
-        spin_unlock_irqrestore(&priv->lock, flags);
-        if (!qh)
-                qtd_list_free(urb, qtd_list);
-        return rc;
-}
-
-static struct isp1760_qtd *isp1760_qtd_alloc(gfp_t flags)
-{
-        struct isp1760_qtd *qtd;
-
-        qtd = kmem_cache_zalloc(qtd_cachep, flags);
-        if (qtd)
-                INIT_LIST_HEAD(&qtd->qtd_list);
-
-        return qtd;
 }
 
 /*
- * create a list of filled qtds for this URB; won't link into qh.
+ * Packetize urb->transfer_buffer into list of packets of size wMaxPacketSize.
+ * Also calculate the PID type (SETUP/IN/OUT) for each packet.
  */
 #define max_packet(wMaxPacketSize) ((wMaxPacketSize) & 0x07ff)
-static struct list_head *qh_urb_transaction(struct usb_hcd *hcd,
+static void packetize_urb(struct usb_hcd *hcd,
                 struct urb *urb, struct list_head *head, gfp_t flags)
 {
         struct isp1760_qtd *qtd;
         void *buf;
-        int len, maxpacket;
-        int is_input;
-        u32 token;
+        int len, maxpacketsize;
+        u8 packet_type;
 
         /*
          * URBs map to sequences of QTDs:  one logical transaction
          */
-        qtd = isp1760_qtd_alloc(flags);
-        if (!qtd)
-                return NULL;
 
-        list_add_tail(&qtd->qtd_list, head);
-        qtd->urb = urb;
-        urb->status = -EINPROGRESS;
+        if (!urb->transfer_buffer && urb->transfer_buffer_length) {
+                /* XXX This looks like usb storage / SCSI bug */
+                dev_err(hcd->self.controller,
+                                "buf is null, dma is %08lx len is %d\n",
+                                (long unsigned)urb->transfer_dma,
+                                urb->transfer_buffer_length);
+                WARN_ON(1);
+        }
 
-        token = 0;
-        /* for split transactions, SplitXState initialized to zero */
+        if (usb_pipein(urb->pipe))
+                packet_type = IN_PID;
+        else
+                packet_type = OUT_PID;
 
-        len = urb->transfer_buffer_length;
-        is_input = usb_pipein(urb->pipe);
         if (usb_pipecontrol(urb->pipe)) {
-                /* SETUP pid */
-                qtd_fill(qtd, urb->setup_packet,
-                                sizeof(struct usb_ctrlrequest),
-                                token | SETUP_PID);
-
-                /* ... and always at least one more pid */
-                qtd = isp1760_qtd_alloc(flags);
+                qtd = qtd_alloc(flags, urb, SETUP_PID);
                 if (!qtd)
                         goto cleanup;
-                qtd->urb = urb;
+                qtd_fill(qtd, urb->setup_packet, sizeof(struct usb_ctrlrequest));
                 list_add_tail(&qtd->qtd_list, head);
 
                 /* for zero length DATA stages, STATUS is always IN */
-                if (len == 0)
-                        token |= IN_PID;
+                if (urb->transfer_buffer_length == 0)
+                        packet_type = IN_PID;
         }
 
-        /*
-         * data transfer stage:  buffer setup
-         */
-        buf = urb->transfer_buffer;
-
-        if (is_input)
-                token |= IN_PID;
-        else
-                token |= OUT_PID;
-
-        maxpacket = max_packet(usb_maxpacket(urb->dev, urb->pipe, !is_input));
+        maxpacketsize = max_packet(usb_maxpacket(urb->dev, urb->pipe,
+                                                usb_pipeout(urb->pipe)));
 
         /*
          * buffer gets wrapped in one or more qtds;
          * last one may be "short" (including zero len)
          * and may serve as a control status ack
          */
+        buf = urb->transfer_buffer;
+        len = urb->transfer_buffer_length;
+
         for (;;) {
                 int this_qtd_len;
 
-                if (!buf && len) {
-                        /* XXX This looks like usb storage / SCSI bug */
-                        dev_err(hcd->self.controller, "buf is null, dma is %08lx len is %d\n",
-                                        (long unsigned)urb->transfer_dma, len);
-                        WARN_ON(1);
-                }
+                qtd = qtd_alloc(flags, urb, packet_type);
+                if (!qtd)
+                        goto cleanup;
+                this_qtd_len = qtd_fill(qtd, buf, len);
+                list_add_tail(&qtd->qtd_list, head);
 
-                this_qtd_len = qtd_fill(qtd, buf, len, token);
                 len -= this_qtd_len;
                 buf += this_qtd_len;
 
                 if (len <= 0)
                         break;
-
-                qtd = isp1760_qtd_alloc(flags);
-                if (!qtd)
-                        goto cleanup;
-                qtd->urb = urb;
-                list_add_tail(&qtd->qtd_list, head);
         }
 
         /*
@@ -1510,184 +1399,163 @@ static struct list_head *qh_urb_transaction(struct usb_hcd *hcd,
 
                 if (usb_pipecontrol(urb->pipe)) {
                         one_more = 1;
-                        /* "in" <--> "out"  */
-                        token ^= IN_PID;
+                        if (packet_type == IN_PID)
+                                packet_type = OUT_PID;
+                        else
+                                packet_type = IN_PID;
                 } else if (usb_pipebulk(urb->pipe)
                                 && (urb->transfer_flags & URB_ZERO_PACKET)
-                                && !(urb->transfer_buffer_length % maxpacket)) {
+                                && !(urb->transfer_buffer_length %
+                                                        maxpacketsize)) {
                         one_more = 1;
                 }
                 if (one_more) {
-                        qtd = isp1760_qtd_alloc(flags);
+                        qtd = qtd_alloc(flags, urb, packet_type);
                         if (!qtd)
                                 goto cleanup;
-                        qtd->urb = urb;
-                        list_add_tail(&qtd->qtd_list, head);
 
                         /* never any data in such packets */
-                        qtd_fill(qtd, NULL, 0, token);
+                        qtd_fill(qtd, NULL, 0);
+                        list_add_tail(&qtd->qtd_list, head);
                 }
         }
 
-        qtd->status = 0;
-        return head;
+        return;
 
 cleanup:
-        qtd_list_free(urb, head);
-        return NULL;
+        qtd_list_free(head);
 }
 
 static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
                 gfp_t mem_flags)
 {
-        struct list_head qtd_list;
-        packet_enqueue *pe;
-
-        INIT_LIST_HEAD(&qtd_list);
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        struct list_head *ep_queue;
+        struct isp1760_qh *qh, *qhit;
+        unsigned long spinflags;
+        LIST_HEAD(new_qtds);
+        int retval;
+        int qh_in_queue;
 
         switch (usb_pipetype(urb->pipe)) {
         case PIPE_CONTROL:
+                ep_queue = &priv->controlqhs;
+                break;
         case PIPE_BULK:
-                if (!qh_urb_transaction(hcd, urb, &qtd_list, mem_flags))
-                        return -ENOMEM;
-                pe =  enqueue_an_ATL_packet;
+                ep_queue = &priv->bulkqhs;
                 break;
-
         case PIPE_INTERRUPT:
-                if (!qh_urb_transaction(hcd, urb, &qtd_list, mem_flags))
-                        return -ENOMEM;
-                pe = enqueue_an_INT_packet;
+                if (urb->interval < 0)
+                        return -EINVAL;
+                /* FIXME: Check bandwidth  */
+                ep_queue = &priv->interruptqhs;
                 break;
-
         case PIPE_ISOCHRONOUS:
-                dev_err(hcd->self.controller, "PIPE_ISOCHRONOUS ain't supported\n");
+                dev_err(hcd->self.controller, "%s: isochronous USB packets "
+                                                        "not yet supported\n",
+                                                        __func__);
+                return -EPIPE;
         default:
+                dev_err(hcd->self.controller, "%s: unknown pipe type\n",
+                                                        __func__);
                 return -EPIPE;
         }
 
-        return isp1760_prepare_enqueue(hcd, urb, &qtd_list, mem_flags, pe);
-}
+        if (usb_pipein(urb->pipe))
+                urb->actual_length = 0;
 
-static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
-{
-        struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        struct inter_packet_info *ints;
-        u32 i;
-        u32 reg_base, or_reg, skip_reg;
-        unsigned long flags;
-        struct ptd ptd;
-        packet_enqueue *pe;
-
-        switch (usb_pipetype(urb->pipe)) {
-        case PIPE_ISOCHRONOUS:
-                return -EPIPE;
-                break;
+        packetize_urb(hcd, urb, &new_qtds, mem_flags);
+        if (list_empty(&new_qtds))
+                return -ENOMEM;
+        urb->hcpriv = NULL; /* Used to signal unlink to interrupt handler */
 
-        case PIPE_INTERRUPT:
-                ints = priv->int_ints;
-                reg_base = INT_PTD_OFFSET;
-                or_reg = HC_INT_IRQ_MASK_OR_REG;
-                skip_reg = HC_INT_PTD_SKIPMAP_REG;
-                pe = enqueue_an_INT_packet;
-                break;
+        retval = 0;
+        spin_lock_irqsave(&priv->lock, spinflags);
 
-        default:
-                ints = priv->atl_ints;
-                reg_base = ATL_PTD_OFFSET;
-                or_reg = HC_ATL_IRQ_MASK_OR_REG;
-                skip_reg = HC_ATL_PTD_SKIPMAP_REG;
-                pe =  enqueue_an_ATL_packet;
-                break;
+        if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
+                retval = -ESHUTDOWN;
+                goto out;
         }
+        retval = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (retval)
+                goto out;
 
-        memset(&ptd, 0, sizeof(ptd));
-        spin_lock_irqsave(&priv->lock, flags);
-
-        for (i = 0; i < 32; i++) {
-                if (!ints[i].qh)
-                        continue;
-                BUG_ON(!ints[i].qtd);
-
-                if (ints[i].qtd->urb == urb) {
-                        u32 skip_map;
-                        u32 or_map;
-                        struct isp1760_qtd *qtd;
-                        struct isp1760_qh *qh;
-
-                        skip_map = reg_read32(hcd->regs, skip_reg);
-                        skip_map |= 1 << i;
-                        reg_write32(hcd->regs, skip_reg, skip_map);
-
-                        or_map = reg_read32(hcd->regs, or_reg);
-                        or_map &= ~(1 << i);
-                        reg_write32(hcd->regs, or_reg, or_map);
-
-                        ptd_write(hcd->regs, reg_base, i, &ptd);
-
-                        qtd = ints[i].qtd;
-                        qh = ints[i].qh;
-
-                        free_mem(hcd, qtd);
-                        qtd = clean_up_qtdlist(qtd, qh);
-
-                        ints[i].qh = NULL;
-                        ints[i].qtd = NULL;
-
-                        urb->status = status;
-                        isp1760_urb_done(hcd, urb);
-                        if (qtd)
-                                pe(hcd, qh, qtd);
-                        break;
-
-                } else {
-                        struct isp1760_qtd *qtd;
-
-                        list_for_each_entry(qtd, &ints[i].qtd->qtd_list,
-                                                                qtd_list) {
-                                if (qtd->urb == urb) {
-                                        clean_up_qtdlist(qtd, ints[i].qh);
-                                        isp1760_urb_done(hcd, urb);
-                                        qtd = NULL;
-                                        break;
-                                }
-                        }
-
-                        /* We found the urb before the last slot */
-                        if (!qtd)
+        qh = urb->ep->hcpriv;
+        if (qh) {
+                qh_in_queue = 0;
+                list_for_each_entry(qhit, ep_queue, qh_list) {
+                        if (qhit == qh) {
+                                qh_in_queue = 1;
                                 break;
+                        }
+                }
+                if (!qh_in_queue)
+                        list_add_tail(&qh->qh_list, ep_queue);
+        } else {
+                qh = qh_alloc(GFP_ATOMIC);
+                if (!qh) {
+                        retval = -ENOMEM;
+                        goto out;
                 }
+                list_add_tail(&qh->qh_list, ep_queue);
+                urb->ep->hcpriv = qh;
         }
 
-        spin_unlock_irqrestore(&priv->lock, flags);
-        return 0;
+        list_splice_tail(&new_qtds, &qh->qtd_list);
+        schedule_ptds(hcd);
+
+out:
+        spin_unlock_irqrestore(&priv->lock, spinflags);
+        return retval;
 }
 
-static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
+static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
+                int status)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
-        u32 imask;
-        irqreturn_t irqret = IRQ_NONE;
+        struct isp1760_qh *qh;
+        struct isp1760_qtd *qtd;
+        struct ptd ptd;
+        unsigned long spinflags;
+        int retval = 0;
 
-        spin_lock(&priv->lock);
+        spin_lock_irqsave(&priv->lock, spinflags);
 
-        if (!(hcd->state & HC_STATE_RUNNING))
-                goto leave;
+        qh = urb->ep->hcpriv;
+        if (!qh) {
+                retval = -EINVAL;
+                goto out;
+        }
 
-        imask = reg_read32(hcd->regs, HC_INTERRUPT_REG);
-        if (unlikely(!imask))
-                goto leave;
+        /* We need to forcefully reclaim the slot since some transfers never
+           return, e.g. interrupt transfers and NAKed bulk transfers. */
+        if (qh->slot > -1) {
+                memset(&ptd, 0, sizeof(ptd));
+                if (usb_pipebulk(urb->pipe)) {
+                        priv->atl_slots[qh->slot].qh = NULL;
+                        priv->atl_slots[qh->slot].qtd = NULL;
+                        ptd_write(hcd->regs, ATL_PTD_OFFSET, qh->slot, &ptd);
+                } else {
+                        priv->int_slots[qh->slot].qh = NULL;
+                        priv->int_slots[qh->slot].qtd = NULL;
+                        ptd_write(hcd->regs, INT_PTD_OFFSET, qh->slot, &ptd);
+                }
+                priv->active_ptds--;
+                qh->slot = -1;
+        }
 
-        reg_write32(hcd->regs, HC_INTERRUPT_REG, imask);
-        if (imask & (HC_ATL_INT | HC_SOT_INT))
-                do_atl_int(hcd);
+        list_for_each_entry(qtd, &qh->qtd_list, qtd_list) {
+                if (qtd->urb == urb)
+                        qtd->status = QTD_RETIRE;
+        }
 
-        if (imask & HC_INTL_INT)
-                do_intl_int(hcd);
+        urb->status = status;
+        schedule_ptds(hcd);
 
-        irqret = IRQ_HANDLED;
-leave:
-        spin_unlock(&priv->lock);
-        return irqret;
+out:
+        spin_unlock_irqrestore(&priv->lock, spinflags);
+
+        return retval;
 }
 
 static int isp1760_hub_status_data(struct usb_hcd *hcd, char *buf)
@@ -1778,7 +1646,7 @@ static int check_reset_complete(struct usb_hcd *hcd, int index,
         /* if reset finished and it's still not enabled -- handoff */
         if (!(port_status & PORT_PE)) {
 
-                dev_err(hcd->self.controller,
+                dev_info(hcd->self.controller,
                                         "port %d full speed --> companion\n",
                                         index + 1);
 
@@ -1787,7 +1655,7 @@ static int check_reset_complete(struct usb_hcd *hcd, int index,
                 reg_write32(hcd->regs, HC_PORTSC1, port_status);
 
         } else
-                dev_err(hcd->self.controller, "port %d high speed\n",
+                dev_info(hcd->self.controller, "port %d high speed\n",
                                                                 index + 1);
 
         return port_status;
@@ -2065,43 +1933,32 @@ static void isp1760_endpoint_disable(struct usb_hcd *hcd,
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
         struct isp1760_qh *qh;
         struct isp1760_qtd *qtd;
-        unsigned long flags;
+        unsigned long spinflags;
+        int do_iter;
 
-        spin_lock_irqsave(&priv->lock, flags);
+        spin_lock_irqsave(&priv->lock, spinflags);
         qh = ep->hcpriv;
         if (!qh)
                 goto out;
 
-        ep->hcpriv = NULL;
-        do {
-                /* more than entry might get removed */
-                if (list_empty(&qh->qtd_list))
-                        break;
-
-                qtd = list_first_entry(&qh->qtd_list, struct isp1760_qtd,
-                                qtd_list);
-
-                if (qtd->status & URB_ENQUEUED) {
-                        spin_unlock_irqrestore(&priv->lock, flags);
-                        isp1760_urb_dequeue(hcd, qtd->urb, -ECONNRESET);
-                        spin_lock_irqsave(&priv->lock, flags);
-                } else {
-                        struct urb *urb;
-
-                        urb = qtd->urb;
-                        clean_up_qtdlist(qtd, qh);
-                        urb->status = -ECONNRESET;
-                        isp1760_urb_done(hcd, urb);
+        do_iter = !list_empty(&qh->qtd_list);
+        while (do_iter) {
+                do_iter = 0;
+                list_for_each_entry(qtd, &qh->qtd_list, qtd_list) {
+                        if (qtd->urb->ep == ep) {
+                                spin_unlock_irqrestore(&priv->lock, spinflags);
+                                isp1760_urb_dequeue(hcd, qtd->urb, -ECONNRESET);
+                                spin_lock_irqsave(&priv->lock, spinflags);
+                                do_iter = 1;
+                                break; /* Restart iteration */
+                        }
                 }
-        } while (1);
+        }
+        ep->hcpriv = NULL;
+        /* Cannot free qh here since it will be parsed by schedule_ptds() */
 
-        qh_destroy(qh);
-        /* remove requests and leak them.
-         * ATL are pretty fast done, INT could take a while...
-         * The latter shoule be removed
-         */
 out:
-        spin_unlock_irqrestore(&priv->lock, flags);
+        spin_unlock_irqrestore(&priv->lock, spinflags);
 }
 
 static int isp1760_get_frame(struct usb_hcd *hcd)
@@ -2165,6 +2022,13 @@ static const struct hc_driver isp1760_hc_driver = {
 
 int __init init_kmem_once(void)
 {
+        urb_listitem_cachep = kmem_cache_create("isp1760 urb_listitem",
+                        sizeof(struct urb_listitem), 0, SLAB_TEMPORARY |
+                        SLAB_MEM_SPREAD, NULL);
+
+        if (!urb_listitem_cachep)
+                return -ENOMEM;
+
         qtd_cachep = kmem_cache_create("isp1760_qtd",
                         sizeof(struct isp1760_qtd), 0, SLAB_TEMPORARY |
                         SLAB_MEM_SPREAD, NULL);
@@ -2187,6 +2051,7 @@ void deinit_kmem_cache(void)
 {
         kmem_cache_destroy(qtd_cachep);
         kmem_cache_destroy(qh_cachep);
+        kmem_cache_destroy(urb_listitem_cachep);
 }
 
 struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h
index 870507690607..014a7dfadf91 100644
--- a/drivers/usb/host/isp1760-hcd.h
+++ b/drivers/usb/host/isp1760-hcd.h
@@ -49,10 +49,9 @@ void deinit_kmem_cache(void);
 #define SW_RESET_RESET_ALL      (1 << 0)
 
 #define HC_BUFFER_STATUS_REG    0x334
-#define ATL_BUFFER              0x1
-#define INT_BUFFER              0x2
-#define ISO_BUFFER              0x4
-#define BUFFER_MAP              0x7
+#define ISO_BUF_FILL            (1 << 2)
+#define INT_BUF_FILL            (1 << 1)
+#define ATL_BUF_FILL            (1 << 0)
 
 #define HC_MEMORY_REG           0x33c
 #define ISP_BANK(x)             ((x) << 16)
@@ -68,14 +67,13 @@ void deinit_kmem_cache(void);
 #define HC_INTERRUPT_REG        0x310
 
 #define HC_INTERRUPT_ENABLE     0x314
-#define INTERRUPT_ENABLE_MASK   (HC_INTL_INT | HC_ATL_INT | HC_EOT_INT)
-#define INTERRUPT_ENABLE_SOT_MASK       (HC_INTL_INT | HC_SOT_INT | HC_EOT_INT)
-
 #define HC_ISO_INT              (1 << 9)
 #define HC_ATL_INT              (1 << 8)
 #define HC_INTL_INT             (1 << 7)
 #define HC_EOT_INT              (1 << 3)
 #define HC_SOT_INT              (1 << 1)
+#define INTERRUPT_ENABLE_MASK   (HC_INTL_INT | HC_ATL_INT)
+#define INTERRUPT_ENABLE_SOT_MASK       (HC_SOT_INT)
 
 #define HC_ISO_IRQ_MASK_OR_REG  0x318
 #define HC_INT_IRQ_MASK_OR_REG  0x31C
@@ -106,7 +104,7 @@ struct ptd {
 #define ATL_PTD_OFFSET          0x0c00
 #define PAYLOAD_OFFSET          0x1000
 
-struct inter_packet_info {
+struct slotinfo {
         struct isp1760_qh *qh;
         struct isp1760_qtd *qtd;
 };
@@ -156,54 +154,52 @@ struct memory_chunk {
 
 /* ATL */
 /* DW0 */
-#define PTD_VALID                       1
-#define PTD_LENGTH(x)                   (((u32) x) << 3)
-#define PTD_MAXPACKET(x)                (((u32) x) << 18)
-#define PTD_MULTI(x)                    (((u32) x) << 29)
-#define PTD_ENDPOINT(x)                 (((u32) x) << 31)
+#define DW0_VALID_BIT                   1
+#define FROM_DW0_VALID(x)               ((x) & 0x01)
+#define TO_DW0_LENGTH(x)                (((u32) x) << 3)
+#define TO_DW0_MAXPACKET(x)             (((u32) x) << 18)
+#define TO_DW0_MULTI(x)                 (((u32) x) << 29)
+#define TO_DW0_ENDPOINT(x)              (((u32) x) << 31)
 /* DW1 */
-#define PTD_DEVICE_ADDR(x)              (((u32) x) << 3)
-#define PTD_PID_TOKEN(x)                (((u32) x) << 10)
-#define PTD_TRANS_BULK                  ((u32) 2 << 12)
-#define PTD_TRANS_INT                   ((u32) 3 << 12)
-#define PTD_TRANS_SPLIT                 ((u32) 1 << 14)
-#define PTD_SE_USB_LOSPEED              ((u32) 2 << 16)
-#define PTD_PORT_NUM(x)                 (((u32) x) << 18)
-#define PTD_HUB_NUM(x)                  (((u32) x) << 25)
-#define PTD_PING(x)                     (((u32) x) << 26)
+#define TO_DW1_DEVICE_ADDR(x)           (((u32) x) << 3)
+#define TO_DW1_PID_TOKEN(x)             (((u32) x) << 10)
+#define DW1_TRANS_BULK                  ((u32) 2 << 12)
+#define DW1_TRANS_INT                   ((u32) 3 << 12)
+#define DW1_TRANS_SPLIT                 ((u32) 1 << 14)
+#define DW1_SE_USB_LOSPEED              ((u32) 2 << 16)
+#define TO_DW1_PORT_NUM(x)              (((u32) x) << 18)
+#define TO_DW1_HUB_NUM(x)               (((u32) x) << 25)
 /* DW2 */
-#define PTD_RL_CNT(x)                   (((u32) x) << 25)
-#define PTD_DATA_START_ADDR(x)          (((u32) x) << 8)
-#define BASE_ADDR                       0x1000
+#define TO_DW2_DATA_START_ADDR(x)       (((u32) x) << 8)
+#define TO_DW2_RL(x)                    ((x) << 25)
+#define FROM_DW2_RL(x)                  (((x) >> 25) & 0xf)
 /* DW3 */
-#define PTD_CERR(x)                     (((u32) x) << 23)
-#define PTD_NAC_CNT(x)                  (((u32) x) << 19)
-#define PTD_ACTIVE                      ((u32) 1 << 31)
-#define PTD_DATA_TOGGLE(x)              (((u32) x) << 25)
-
-#define DW3_HALT_BIT                    (1 << 30)
+#define FROM_DW3_NRBYTESTRANSFERRED(x)          ((x) & 0x7fff)
+#define FROM_DW3_SCS_NRBYTESTRANSFERRED(x)      ((x) & 0x07ff)
+#define TO_DW3_NAKCOUNT(x)              ((x) << 19)
+#define FROM_DW3_NAKCOUNT(x)            (((x) >> 19) & 0xf)
+#define TO_DW3_CERR(x)                  ((x) << 23)
+#define FROM_DW3_CERR(x)                (((x) >> 23) & 0x3)
+#define TO_DW3_DATA_TOGGLE(x)           ((x) << 25)
+#define FROM_DW3_DATA_TOGGLE(x)         (((x) >> 25) & 0x1)
+#define TO_DW3_PING(x)                  ((x) << 26)
+#define FROM_DW3_PING(x)                (((x) >> 26) & 0x1)
 #define DW3_ERROR_BIT                   (1 << 28)
-#define DW3_QTD_ACTIVE                  (1 << 31)
+#define DW3_BABBLE_BIT                  (1 << 29)
+#define DW3_HALT_BIT                    (1 << 30)
+#define DW3_ACTIVE_BIT                  (1 << 31)
 
 #define INT_UNDERRUN                    (1 << 2)
 #define INT_BABBLE                      (1 << 1)
 #define INT_EXACT                       (1 << 0)
 
-#define DW1_GET_PID(x)                  (((x) >> 10) & 0x3)
-#define PTD_XFERRED_LENGTH(x)           ((x) & 0x7fff)
-#define PTD_XFERRED_LENGTH_LO(x)        ((x) & 0x7ff)
-
 #define SETUP_PID       (2)
 #define IN_PID          (1)
 #define OUT_PID         (0)
-#define GET_QTD_TOKEN_TYPE(x)   ((x) & 0x3)
-
-#define DATA_TOGGLE             (1 << 31)
-#define GET_DATA_TOGGLE(x)      ((x) >> 31)
 
 /* Errata 1 */
 #define RL_COUNTER      (0)
 #define NAK_COUNTER     (0)
 #define ERR_COUNTER     (2)
 
-#endif
+#endif /* _ISP1760_HCD_H_ */
diff --git a/drivers/usb/host/octeon2-common.c b/drivers/usb/host/octeon2-common.c
index 72d672cfcf39..d9df423f3d12 100644
--- a/drivers/usb/host/octeon2-common.c
+++ b/drivers/usb/host/octeon2-common.c
@@ -3,18 +3,19 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2010 Cavium Networks
+ * Copyright (C) 2010, 2011 Cavium Networks
  */
 
 #include <linux/module.h>
+#include <linux/mutex.h>
 #include <linux/delay.h>
 
-#include <asm/atomic.h>
-
 #include <asm/octeon/octeon.h>
 #include <asm/octeon/cvmx-uctlx-defs.h>
 
-static atomic_t  octeon2_usb_clock_start_cnt = ATOMIC_INIT(0);
+static DEFINE_MUTEX(octeon2_usb_clocks_mutex);
+
+static int octeon2_usb_clock_start_cnt;
 
 void octeon2_usb_clocks_start(void)
 {
@@ -26,8 +27,12 @@ void octeon2_usb_clocks_start(void)
         int i;
         unsigned long io_clk_64_to_ns;
 
-        if (atomic_inc_return(&octeon2_usb_clock_start_cnt) != 1)
-                return;
+
+        mutex_lock(&octeon2_usb_clocks_mutex);
+
+        octeon2_usb_clock_start_cnt++;
+        if (octeon2_usb_clock_start_cnt != 1)
+                goto exit;
 
         io_clk_64_to_ns = 64000000000ull / octeon_get_io_clock_rate();
 
@@ -43,6 +48,13 @@ void octeon2_usb_clocks_start(void)
 
         /* Step 3: Configure the reference clock, PHY, and HCLK */
         clk_rst_ctl.u64 = cvmx_read_csr(CVMX_UCTLX_CLK_RST_CTL(0));
+
+        /*
+         * If the UCTL looks like it has already been started, skip
+         * the initialization, otherwise bus errors are obtained.
+         */
+        if (clk_rst_ctl.s.hrst)
+                goto end_clock;
         /* 3a */
         clk_rst_ctl.s.p_por = 1;
         clk_rst_ctl.s.hrst = 0;
@@ -158,28 +170,31 @@ void octeon2_usb_clocks_start(void)
         clk_rst_ctl.s.hrst = 1;
         cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
 
+end_clock:
         /* Now we can set some other registers.  */
 
         for (i = 0; i <= 1; i++) {
                 port_ctl_status.u64 =
                         cvmx_read_csr(CVMX_UCTLX_UPHY_PORTX_CTL_STATUS(i, 0));
-                /* Set txvreftune to 15 to obtain complient 'eye' diagram. */
+                /* Set txvreftune to 15 to obtain compliant 'eye' diagram. */
                 port_ctl_status.s.txvreftune = 15;
+                port_ctl_status.s.txrisetune = 1;
+                port_ctl_status.s.txpreemphasistune = 1;
                 cvmx_write_csr(CVMX_UCTLX_UPHY_PORTX_CTL_STATUS(i, 0),
                                port_ctl_status.u64);
         }
+
+        /* Set uSOF cycle period to 60,000 bits. */
+        cvmx_write_csr(CVMX_UCTLX_EHCI_FLA(0), 0x20ull);
+exit:
+        mutex_unlock(&octeon2_usb_clocks_mutex);
 }
 EXPORT_SYMBOL(octeon2_usb_clocks_start);
 
 void octeon2_usb_clocks_stop(void)
 {
-        union cvmx_uctlx_if_ena if_ena;
-
-        if (atomic_dec_return(&octeon2_usb_clock_start_cnt) != 0)
-                return;
-
-        if_ena.u64 = 0;
-        if_ena.s.en = 0;
-        cvmx_write_csr(CVMX_UCTLX_IF_ENA(0), if_ena.u64);
+        mutex_lock(&octeon2_usb_clocks_mutex);
+        octeon2_usb_clock_start_cnt--;
+        mutex_unlock(&octeon2_usb_clocks_mutex);
 }
 EXPORT_SYMBOL(octeon2_usb_clocks_stop);
diff --git a/drivers/usb/host/ohci-ath79.c b/drivers/usb/host/ohci-ath79.c
new file mode 100644
index 000000000000..ffea3e7cb0a8
--- /dev/null
+++ b/drivers/usb/host/ohci-ath79.c
@@ -0,0 +1,151 @@
+/*
+ *  OHCI HCD (Host Controller Driver) for USB.
+ *
+ *  Bus Glue for Atheros AR71XX/AR724X built-in OHCI controller.
+ *
+ *  Copyright (C) 2008-2011 Gabor Juhos <juhosg@openwrt.org>
+ *  Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org>
+ *
+ *  Parts of this file are based on Atheros' 2.6.15 BSP
+ *      Copyright (C) 2007 Atheros Communications, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 as published
+ *  by the Free Software Foundation.
+ */
+
+#include <linux/platform_device.h>
+
+static int __devinit ohci_ath79_start(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        int ret;
+
+        ret = ohci_init(ohci);
+        if (ret < 0)
+                return ret;
+
+        ret = ohci_run(ohci);
+        if (ret < 0)
+                goto err;
+
+        return 0;
+
+err:
+        ohci_stop(hcd);
+        return ret;
+}
+
+static const struct hc_driver ohci_ath79_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Atheros built-in OHCI controller",
+        .hcd_priv_size          = sizeof(struct ohci_hcd),
+
+        .irq                    = ohci_irq,
+        .flags                  = HCD_USB11 | HCD_MEMORY,
+
+        .start                  = ohci_ath79_start,
+        .stop                   = ohci_stop,
+        .shutdown               = ohci_shutdown,
+
+        .urb_enqueue            = ohci_urb_enqueue,
+        .urb_dequeue            = ohci_urb_dequeue,
+        .endpoint_disable       = ohci_endpoint_disable,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ohci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ohci_hub_status_data,
+        .hub_control            = ohci_hub_control,
+        .start_port_reset       = ohci_start_port_reset,
+};
+
+static int ohci_ath79_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res;
+        int irq;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_dbg(&pdev->dev, "no IRQ specified\n");
+                return -ENODEV;
+        }
+        irq = res->start;
+
+        hcd = usb_create_hcd(&ohci_ath79_hc_driver, &pdev->dev,
+                             dev_name(&pdev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_dbg(&pdev->dev, "no base address specified\n");
+                ret = -ENODEV;
+                goto err_put_hcd;
+        }
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len   = res->end - res->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                ret = -EBUSY;
+                goto err_put_hcd;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                ret = -EFAULT;
+                goto err_release_region;
+        }
+
+        ohci_hcd_init(hcd_to_ohci(hcd));
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        if (ret)
+                goto err_stop_hcd;
+
+        return 0;
+
+err_stop_hcd:
+        iounmap(hcd->regs);
+err_release_region:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_put_hcd:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int ohci_ath79_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+static struct platform_driver ohci_hcd_ath79_driver = {
+        .probe          = ohci_ath79_probe,
+        .remove         = ohci_ath79_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver         = {
+                .name   = "ath79-ohci",
+                .owner  = THIS_MODULE,
+        },
+};
+
+MODULE_ALIAS(PLATFORM_MODULE_PREFIX "ath79-ohci");
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index d55723514860..8c8dc6559ac7 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1105,6 +1105,11 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ohci_hcd_cns3xxx_driver
 #endif
 
+#ifdef CONFIG_USB_OHCI_ATH79
+#include "ohci-ath79.c"
+#define PLATFORM_DRIVER         ohci_hcd_ath79_driver
+#endif
+
 #if     !defined(PCI_DRIVER) &&         \
         !defined(PLATFORM_DRIVER) &&    \
         !defined(OMAP1_PLATFORM_DRIVER) &&      \
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index a68af2dd55ca..7c9a4d55526b 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -56,9 +56,8 @@ static void s3c2410_start_hc(struct platform_device *dev, struct usb_hcd *hcd)
                 info->hcd       = hcd;
                 info->report_oc = s3c2410_hcd_oc;
 
-                if (info->enable_oc != NULL) {
+                if (info->enable_oc != NULL)
                         (info->enable_oc)(info, 1);
-                }
         }
 }
 
@@ -72,9 +71,8 @@ static void s3c2410_stop_hc(struct platform_device *dev)
                 info->report_oc = NULL;
                 info->hcd       = NULL;
 
-                if (info->enable_oc != NULL) {
+                if (info->enable_oc != NULL)
                         (info->enable_oc)(info, 0);
-                }
         }
 
         clk_disable(clk);
@@ -88,14 +86,14 @@ static void s3c2410_stop_hc(struct platform_device *dev)
 */
 
 static int
-ohci_s3c2410_hub_status_data (struct usb_hcd *hcd, char *buf)
+ohci_s3c2410_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
         struct s3c2410_hcd_info *info = to_s3c2410_info(hcd);
         struct s3c2410_hcd_port *port;
         int orig;
         int portno;
 
-        orig  = ohci_hub_status_data (hcd, buf);
+        orig  = ohci_hub_status_data(hcd, buf);
 
         if (info == NULL)
                 return orig;
@@ -145,7 +143,7 @@ static void s3c2410_usb_set_power(struct s3c2410_hcd_info *info,
  * request.
 */
 
-static int ohci_s3c2410_hub_control (
+static int ohci_s3c2410_hub_control(
         struct usb_hcd  *hcd,
         u16             typeReq,
         u16             wValue,
@@ -199,9 +197,8 @@ static int ohci_s3c2410_hub_control (
                         dev_dbg(hcd->self.controller,
                                 "ClearPortFeature: OVER_CURRENT\n");
 
-                        if (valid_port(wIndex)) {
+                        if (valid_port(wIndex))
                                 info->port[wIndex-1].oc_status = 0;
-                        }
 
                         goto out;
 
@@ -242,8 +239,11 @@ static int ohci_s3c2410_hub_control (
                 desc->wHubCharacteristics |= cpu_to_le16(0x0001);
 
                 if (info->enable_oc) {
-                        desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
-                        desc->wHubCharacteristics |=  cpu_to_le16(0x0008|0x0001);
+                        desc->wHubCharacteristics &= ~cpu_to_le16(
+                                HUB_CHAR_OCPM);
+                        desc->wHubCharacteristics |=  cpu_to_le16(
+                                0x0008 |
+                                0x0001);
                 }
 
                 dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
@@ -257,13 +257,11 @@ static int ohci_s3c2410_hub_control (
                 dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex);
 
                 if (valid_port(wIndex)) {
-                        if (info->port[wIndex-1].oc_changed) {
+                        if (info->port[wIndex-1].oc_changed)
                                 *data |= cpu_to_le32(RH_PS_OCIC);
-                        }
 
-                        if (info->port[wIndex-1].oc_status) {
+                        if (info->port[wIndex-1].oc_status)
                                 *data |= cpu_to_le32(RH_PS_POCI);
-                        }
                 }
         }
 
@@ -321,7 +319,7 @@ static void s3c2410_hcd_oc(struct s3c2410_hcd_info *info, int port_oc)
 */
 
 static void
-usb_hcd_s3c2410_remove (struct usb_hcd *hcd, struct platform_device *dev)
+usb_hcd_s3c2410_remove(struct usb_hcd *hcd, struct platform_device *dev)
 {
         usb_remove_hcd(hcd);
         s3c2410_stop_hc(dev);
@@ -339,7 +337,7 @@ usb_hcd_s3c2410_remove (struct usb_hcd *hcd, struct platform_device *dev)
  * through the hotplug entry's driver_data.
  *
  */
-static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
+static int usb_hcd_s3c2410_probe(const struct hc_driver *driver,
                                   struct platform_device *dev)
 {
         struct usb_hcd *hcd = NULL;
@@ -353,7 +351,7 @@ static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
                 return -ENOMEM;
 
         hcd->rsrc_start = dev->resource[0].start;
-        hcd->rsrc_len   = dev->resource[0].end - dev->resource[0].start + 1;
+        hcd->rsrc_len   = resource_size(&dev->resource[0]);
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                 dev_err(&dev->dev, "request_mem_region failed\n");
@@ -364,14 +362,14 @@ static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
         clk = clk_get(&dev->dev, "usb-host");
         if (IS_ERR(clk)) {
                 dev_err(&dev->dev, "cannot get usb-host clock\n");
-                retval = -ENOENT;
+                retval = PTR_ERR(clk);
                 goto err_mem;
         }
 
         usb_clk = clk_get(&dev->dev, "usb-bus-host");
         if (IS_ERR(usb_clk)) {
                 dev_err(&dev->dev, "cannot get usb-bus-host clock\n");
-                retval = -ENOENT;
+                retval = PTR_ERR(usb_clk);
                 goto err_clk;
         }
 
@@ -411,17 +409,19 @@ static int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
 /*-------------------------------------------------------------------------*/
 
 static int
-ohci_s3c2410_start (struct usb_hcd *hcd)
+ohci_s3c2410_start(struct usb_hcd *hcd)
 {
-        struct ohci_hcd *ohci = hcd_to_ohci (hcd);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
         int ret;
 
-        if ((ret = ohci_init(ohci)) < 0)
+        ret = ohci_init(ohci);
+        if (ret < 0)
                 return ret;
 
-        if ((ret = ohci_run (ohci)) < 0) {
-                err ("can't start %s", hcd->self.bus_name);
-                ohci_stop (hcd);
+        ret = ohci_run(ohci);
+        if (ret < 0) {
+                err("can't start %s", hcd->self.bus_name);
+                ohci_stop(hcd);
                 return ret;
         }
 
@@ -473,12 +473,12 @@ static const struct hc_driver ohci_s3c2410_hc_driver = {
 
 /* device driver */
 
-static int ohci_hcd_s3c2410_drv_probe(struct platform_device *pdev)
+static int __devinit ohci_hcd_s3c2410_drv_probe(struct platform_device *pdev)
 {
         return usb_hcd_s3c2410_probe(&ohci_s3c2410_hc_driver, pdev);
 }
 
-static int ohci_hcd_s3c2410_drv_remove(struct platform_device *pdev)
+static int __devexit ohci_hcd_s3c2410_drv_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
@@ -488,7 +488,7 @@ static int ohci_hcd_s3c2410_drv_remove(struct platform_device *pdev)
 
 static struct platform_driver ohci_hcd_s3c2410_driver = {
         .probe          = ohci_hcd_s3c2410_drv_probe,
-        .remove         = ohci_hcd_s3c2410_drv_remove,
+        .remove         = __devexit_p(ohci_hcd_s3c2410_drv_remove),
         .shutdown       = usb_hcd_platform_shutdown,
         /*.suspend      = ohci_hcd_s3c2410_drv_suspend, */
         /*.resume       = ohci_hcd_s3c2410_drv_resume, */
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 18b7099a8125..5adcba016fcf 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -71,12 +71,6 @@ MODULE_ALIAS("platform:sl811-hcd");
 /* for now, use only one transfer register bank */
 #undef  USE_B
 
-/* this doesn't understand urb->iso_frame_desc[], but if you had a driver
- * that just queued one ISO frame per URB then iso transfers "should" work
- * using the normal urb status fields.
- */
-#define DISABLE_ISO
-
 // #define      QUIRK2
 #define QUIRK3
 
@@ -807,7 +801,7 @@ static int sl811h_urb_enqueue(
         int                     retval;
         struct usb_host_endpoint        *hep = urb->ep;
 
-#ifdef  DISABLE_ISO
+#ifndef CONFIG_USB_SL811_HCD_ISO
         if (type == PIPE_ISOCHRONOUS)
                 return -ENOSPC;
 #endif
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index b4785934e091..533d12cca371 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -3230,8 +3230,7 @@ static int __init u132_hcd_init(void)
         mutex_init(&u132_module_lock);
         if (usb_disabled())
                 return -ENODEV;
-        printk(KERN_INFO "driver %s built at %s on %s\n", hcd_name, __TIME__,
-                __DATE__);
+        printk(KERN_INFO "driver %s\n", hcd_name);
         workqueue = create_singlethread_workqueue("u132");
         retval = platform_driver_register(&u132_platform_driver);
         return retval;
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index ee60cd3ea642..f882a84b1bbb 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -285,7 +285,6 @@ static int uhci_show_root_hub_state(struct uhci_hcd *uhci, char *buf, int len)
 static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
 {
         char *out = buf;
-        unsigned long io_addr = uhci->io_addr;
         unsigned short usbcmd, usbstat, usbint, usbfrnum;
         unsigned int flbaseadd;
         unsigned char sof;
@@ -295,14 +294,14 @@ static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
         if (len < 80 * 9)
                 return 0;
 
-        usbcmd    = inw(io_addr + 0);
-        usbstat   = inw(io_addr + 2);
-        usbint    = inw(io_addr + 4);
-        usbfrnum  = inw(io_addr + 6);
-        flbaseadd = inl(io_addr + 8);
-        sof       = inb(io_addr + 12);
-        portsc1   = inw(io_addr + 16);
-        portsc2   = inw(io_addr + 18);
+        usbcmd    = uhci_readw(uhci, 0);
+        usbstat   = uhci_readw(uhci, 2);
+        usbint    = uhci_readw(uhci, 4);
+        usbfrnum  = uhci_readw(uhci, 6);
+        flbaseadd = uhci_readl(uhci, 8);
+        sof       = uhci_readb(uhci, 12);
+        portsc1   = uhci_readw(uhci, 16);
+        portsc2   = uhci_readw(uhci, 18);
 
         out += sprintf(out, "  usbcmd    =     %04x   %s%s%s%s%s%s%s%s\n",
                 usbcmd,
diff --git a/drivers/usb/host/uhci-grlib.c b/drivers/usb/host/uhci-grlib.c
new file mode 100644
index 000000000000..b1addd60a1ef
--- /dev/null
+++ b/drivers/usb/host/uhci-grlib.c
@@ -0,0 +1,194 @@
+/*
+ * UHCI HCD (Host Controller Driver) for GRLIB GRUSBHC
+ *
+ * Copyright (c) 2011 Jan Andersson <jan@gaisler.com>
+ *
+ * This file is based on UHCI PCI HCD:
+ * (C) Copyright 1999 Linus Torvalds
+ * (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com
+ * (C) Copyright 1999 Randy Dunlap
+ * (C) Copyright 1999 Georg Acher, acher@in.tum.de
+ * (C) Copyright 1999 Deti Fliegl, deti@fliegl.de
+ * (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch
+ * (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at
+ * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface
+ *               support from usb-ohci.c by Adam Richter, adam@yggdrasil.com).
+ * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c)
+ * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
+ */
+
+#include <linux/of_irq.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+
+static int uhci_grlib_init(struct usb_hcd *hcd)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+
+        uhci->rh_numports = uhci_count_ports(hcd);
+
+        /* Set up pointers to to generic functions */
+        uhci->reset_hc = uhci_generic_reset_hc;
+        uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc;
+        /* No special actions need to be taken for the functions below */
+        uhci->configure_hc = NULL;
+        uhci->resume_detect_interrupts_are_broken = NULL;
+        uhci->global_suspend_mode_is_broken = NULL;
+
+        /* Reset if the controller isn't already safely quiescent. */
+        check_and_reset_hc(uhci);
+        return 0;
+}
+
+static const struct hc_driver uhci_grlib_hc_driver = {
+        .description =          hcd_name,
+        .product_desc =         "GRLIB GRUSBHC UHCI Host Controller",
+        .hcd_priv_size =        sizeof(struct uhci_hcd),
+
+        /* Generic hardware linkage */
+        .irq =                  uhci_irq,
+        .flags =                HCD_MEMORY | HCD_USB11,
+
+        /* Basic lifecycle operations */
+        .reset =                uhci_grlib_init,
+        .start =                uhci_start,
+#ifdef CONFIG_PM
+        .pci_suspend =          NULL,
+        .pci_resume =           NULL,
+        .bus_suspend =          uhci_rh_suspend,
+        .bus_resume =           uhci_rh_resume,
+#endif
+        .stop =                 uhci_stop,
+
+        .urb_enqueue =          uhci_urb_enqueue,
+        .urb_dequeue =          uhci_urb_dequeue,
+
+        .endpoint_disable =     uhci_hcd_endpoint_disable,
+        .get_frame_number =     uhci_hcd_get_frame_number,
+
+        .hub_status_data =      uhci_hub_status_data,
+        .hub_control =          uhci_hub_control,
+};
+
+
+static int __devinit uhci_hcd_grlib_probe(struct platform_device *op)
+{
+        struct device_node *dn = op->dev.of_node;
+        struct usb_hcd *hcd;
+        struct uhci_hcd *uhci = NULL;
+        struct resource res;
+        int irq;
+        int rv;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        dev_dbg(&op->dev, "initializing GRUSBHC UHCI USB Controller\n");
+
+        rv = of_address_to_resource(dn, 0, &res);
+        if (rv)
+                return rv;
+
+        /* usb_create_hcd requires dma_mask != NULL */
+        op->dev.dma_mask = &op->dev.coherent_dma_mask;
+        hcd = usb_create_hcd(&uhci_grlib_hc_driver, &op->dev,
+                        "GRUSBHC UHCI USB");
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res.start;
+        hcd->rsrc_len = res.end - res.start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_rmr;
+        }
+
+        irq = irq_of_parse_and_map(dn, 0);
+        if (irq == NO_IRQ) {
+                printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_irq;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
+                rv = -ENOMEM;
+                goto err_ioremap;
+        }
+
+        uhci = hcd_to_uhci(hcd);
+
+        uhci->regs = hcd->regs;
+
+        rv = usb_add_hcd(hcd, irq, 0);
+        if (rv)
+                goto err_uhci;
+
+        return 0;
+
+err_uhci:
+        iounmap(hcd->regs);
+err_ioremap:
+        irq_dispose_mapping(irq);
+err_irq:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_rmr:
+        usb_put_hcd(hcd);
+
+        return rv;
+}
+
+static int uhci_hcd_grlib_remove(struct platform_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        dev_set_drvdata(&op->dev, NULL);
+
+        dev_dbg(&op->dev, "stopping GRLIB GRUSBHC UHCI USB Controller\n");
+
+        usb_remove_hcd(hcd);
+
+        iounmap(hcd->regs);
+        irq_dispose_mapping(hcd->irq);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+/* Make sure the controller is quiescent and that we're not using it
+ * any more.  This is mainly for the benefit of programs which, like kexec,
+ * expect the hardware to be idle: not doing DMA or generating IRQs.
+ *
+ * This routine may be called in a damaged or failing kernel.  Hence we
+ * do not acquire the spinlock before shutting down the controller.
+ */
+static void uhci_hcd_grlib_shutdown(struct platform_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        uhci_hc_died(hcd_to_uhci(hcd));
+}
+
+static const struct of_device_id uhci_hcd_grlib_of_match[] = {
+        { .name = "GAISLER_UHCI", },
+        { .name = "01_027", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, uhci_hcd_grlib_of_match);
+
+
+static struct platform_driver uhci_grlib_driver = {
+        .probe          = uhci_hcd_grlib_probe,
+        .remove         = uhci_hcd_grlib_remove,
+        .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-hcd.c b/drivers/usb/host/uhci-hcd.c
index 4f65b14e5e08..79dd822e58d1 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -48,7 +48,6 @@
 #include <asm/system.h>
 
 #include "uhci-hcd.h"
-#include "pci-quirks.h"
 
 /*
  * Version Information
@@ -134,15 +133,12 @@ static void finish_reset(struct uhci_hcd *uhci)
          * We have to clear them by hand.
          */
         for (port = 0; port < uhci->rh_numports; ++port)
-                outw(0, uhci->io_addr + USBPORTSC1 + (port * 2));
+                uhci_writew(uhci, 0, USBPORTSC1 + (port * 2));
 
         uhci->port_c_suspend = uhci->resuming_ports = 0;
         uhci->rh_state = UHCI_RH_RESET;
         uhci->is_stopped = UHCI_IS_STOPPED;
-        uhci_to_hcd(uhci)->state = HC_STATE_HALT;
         clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
-
-        uhci->dead = 0;         /* Full reset resurrects the controller */
 }
 
 /*
@@ -152,7 +148,7 @@ static void finish_reset(struct uhci_hcd *uhci)
 static void uhci_hc_died(struct uhci_hcd *uhci)
 {
         uhci_get_current_frame_number(uhci);
-        uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr);
+        uhci->reset_hc(uhci);
         finish_reset(uhci);
         uhci->dead = 1;
 
@@ -167,97 +163,118 @@ static void uhci_hc_died(struct uhci_hcd *uhci)
  */
 static void check_and_reset_hc(struct uhci_hcd *uhci)
 {
-        if (uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr))
+        if (uhci->check_and_reset_hc(uhci))
                 finish_reset(uhci);
 }
 
+#if defined(CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC)
+/*
+ * The two functions below are generic reset functions that are used on systems
+ * that do not have keyboard and mouse legacy support. We assume that we are
+ * running on such a system if CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC is defined.
+ */
+
+/*
+ * Make sure the controller is completely inactive, unable to
+ * generate interrupts or do DMA.
+ */
+static void uhci_generic_reset_hc(struct uhci_hcd *uhci)
+{
+        /* Reset the HC - this will force us to get a
+         * new notification of any already connected
+         * ports due to the virtual disconnect that it
+         * implies.
+         */
+        uhci_writew(uhci, USBCMD_HCRESET, USBCMD);
+        mb();
+        udelay(5);
+        if (uhci_readw(uhci, USBCMD) & USBCMD_HCRESET)
+                dev_warn(uhci_dev(uhci), "HCRESET not completed yet!\n");
+
+        /* Just to be safe, disable interrupt requests and
+         * make sure the controller is stopped.
+         */
+        uhci_writew(uhci, 0, USBINTR);
+        uhci_writew(uhci, 0, USBCMD);
+}
+
+/*
+ * Initialize a controller that was newly discovered or has just been
+ * resumed.  In either case we can't be sure of its previous state.
+ *
+ * Returns: 1 if the controller was reset, 0 otherwise.
+ */
+static int uhci_generic_check_and_reset_hc(struct uhci_hcd *uhci)
+{
+        unsigned int cmd, intr;
+
+        /*
+         * When restarting a suspended controller, we expect all the
+         * settings to be the same as we left them:
+         *
+         *      Controller is stopped and configured with EGSM set;
+         *      No interrupts enabled except possibly Resume Detect.
+         *
+         * If any of these conditions are violated we do a complete reset.
+         */
+
+        cmd = uhci_readw(uhci, USBCMD);
+        if ((cmd & USBCMD_RS) || !(cmd & USBCMD_CF) || !(cmd & USBCMD_EGSM)) {
+                dev_dbg(uhci_dev(uhci), "%s: cmd = 0x%04x\n",
+                                __func__, cmd);
+                goto reset_needed;
+        }
+
+        intr = uhci_readw(uhci, USBINTR);
+        if (intr & (~USBINTR_RESUME)) {
+                dev_dbg(uhci_dev(uhci), "%s: intr = 0x%04x\n",
+                                __func__, intr);
+                goto reset_needed;
+        }
+        return 0;
+
+reset_needed:
+        dev_dbg(uhci_dev(uhci), "Performing full reset\n");
+        uhci_generic_reset_hc(uhci);
+        return 1;
+}
+#endif /* CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC */
+
 /*
  * Store the basic register settings needed by the controller.
  */
 static void configure_hc(struct uhci_hcd *uhci)
 {
-        struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
-
         /* Set the frame length to the default: 1 ms exactly */
-        outb(USBSOF_DEFAULT, uhci->io_addr + USBSOF);
+        uhci_writeb(uhci, USBSOF_DEFAULT, USBSOF);
 
         /* Store the frame list base address */
-        outl(uhci->frame_dma_handle, uhci->io_addr + USBFLBASEADD);
+        uhci_writel(uhci, uhci->frame_dma_handle, USBFLBASEADD);
 
         /* Set the current frame number */
-        outw(uhci->frame_number & UHCI_MAX_SOF_NUMBER,
-                        uhci->io_addr + USBFRNUM);
-
-        /* Mark controller as not halted before we enable interrupts */
-        uhci_to_hcd(uhci)->state = HC_STATE_SUSPENDED;
-        mb();
-
-        /* Enable PIRQ */
-        pci_write_config_word(pdev, USBLEGSUP, USBLEGSUP_DEFAULT);
+        uhci_writew(uhci, uhci->frame_number & UHCI_MAX_SOF_NUMBER,
+                        USBFRNUM);
 
-        /* Disable platform-specific non-PME# wakeup */
-        if (pdev->vendor == PCI_VENDOR_ID_INTEL)
-                pci_write_config_byte(pdev, USBRES_INTEL, 0);
+        /* perform any arch/bus specific configuration */
+        if (uhci->configure_hc)
+                uhci->configure_hc(uhci);
 }
 
-
 static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
 {
-        int port;
-
         /* If we have to ignore overcurrent events then almost by definition
          * we can't depend on resume-detect interrupts. */
         if (ignore_oc)
                 return 1;
 
-        switch (to_pci_dev(uhci_dev(uhci))->vendor) {
-            default:
-                break;
-
-            case PCI_VENDOR_ID_GENESYS:
-                /* Genesys Logic's GL880S controllers don't generate
-                 * resume-detect interrupts.
-                 */
-                return 1;
-
-            case PCI_VENDOR_ID_INTEL:
-                /* Some of Intel's USB controllers have a bug that causes
-                 * resume-detect interrupts if any port has an over-current
-                 * condition.  To make matters worse, some motherboards
-                 * hardwire unused USB ports' over-current inputs active!
-                 * To prevent problems, we will not enable resume-detect
-                 * interrupts if any ports are OC.
-                 */
-                for (port = 0; port < uhci->rh_numports; ++port) {
-                        if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
-                                        USBPORTSC_OC)
-                                return 1;
-                }
-                break;
-        }
-        return 0;
+        return uhci->resume_detect_interrupts_are_broken ?
+                uhci->resume_detect_interrupts_are_broken(uhci) : 0;
 }
 
 static int global_suspend_mode_is_broken(struct uhci_hcd *uhci)
 {
-        int port;
-        const char *sys_info;
-        static char bad_Asus_board[] = "A7V8X";
-
-        /* One of Asus's motherboards has a bug which causes it to
-         * wake up immediately from suspend-to-RAM if any of the ports
-         * are connected.  In such cases we will not set EGSM.
-         */
-        sys_info = dmi_get_system_info(DMI_BOARD_NAME);
-        if (sys_info && !strcmp(sys_info, bad_Asus_board)) {
-                for (port = 0; port < uhci->rh_numports; ++port) {
-                        if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
-                                        USBPORTSC_CCS)
-                                return 1;
-                }
-        }
-
-        return 0;
+        return uhci->global_suspend_mode_is_broken ?
+                uhci->global_suspend_mode_is_broken(uhci) : 0;
 }
 
 static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state)
@@ -320,8 +337,8 @@ __acquires(uhci->lock)
                         !int_enable)
                 uhci->RD_enable = int_enable = 0;
 
-        outw(int_enable, uhci->io_addr + USBINTR);
-        outw(egsm_enable | USBCMD_CF, uhci->io_addr + USBCMD);
+        uhci_writew(uhci, int_enable, USBINTR);
+        uhci_writew(uhci, egsm_enable | USBCMD_CF, USBCMD);
         mb();
         udelay(5);
 
@@ -330,7 +347,7 @@ __acquires(uhci->lock)
          * controller should stop after a few microseconds.  Otherwise
          * we will give the controller one frame to stop.
          */
-        if (!auto_stop && !(inw(uhci->io_addr + USBSTS) & USBSTS_HCH)) {
+        if (!auto_stop && !(uhci_readw(uhci, USBSTS) & USBSTS_HCH)) {
                 uhci->rh_state = UHCI_RH_SUSPENDING;
                 spin_unlock_irq(&uhci->lock);
                 msleep(1);
@@ -338,7 +355,7 @@ __acquires(uhci->lock)
                 if (uhci->dead)
                         return;
         }
-        if (!(inw(uhci->io_addr + USBSTS) & USBSTS_HCH))
+        if (!(uhci_readw(uhci, USBSTS) & USBSTS_HCH))
                 dev_warn(uhci_dev(uhci), "Controller not stopped yet!\n");
 
         uhci_get_current_frame_number(uhci);
@@ -360,15 +377,14 @@ __acquires(uhci->lock)
 
 static void start_rh(struct uhci_hcd *uhci)
 {
-        uhci_to_hcd(uhci)->state = HC_STATE_RUNNING;
         uhci->is_stopped = 0;
 
         /* Mark it configured and running with a 64-byte max packet.
          * All interrupts are enabled, even though RESUME won't do anything.
          */
-        outw(USBCMD_RS | USBCMD_CF | USBCMD_MAXP, uhci->io_addr + USBCMD);
-        outw(USBINTR_TIMEOUT | USBINTR_RESUME | USBINTR_IOC | USBINTR_SP,
-                        uhci->io_addr + USBINTR);
+        uhci_writew(uhci, USBCMD_RS | USBCMD_CF | USBCMD_MAXP, USBCMD);
+        uhci_writew(uhci, USBINTR_TIMEOUT | USBINTR_RESUME |
+                USBINTR_IOC | USBINTR_SP, USBINTR);
         mb();
         uhci->rh_state = UHCI_RH_RUNNING;
         set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
@@ -391,9 +407,9 @@ __acquires(uhci->lock)
                 unsigned egsm;
 
                 /* Keep EGSM on if it was set before */
-                egsm = inw(uhci->io_addr + USBCMD) & USBCMD_EGSM;
+                egsm = uhci_readw(uhci, USBCMD) & USBCMD_EGSM;
                 uhci->rh_state = UHCI_RH_RESUMING;
-                outw(USBCMD_FGR | USBCMD_CF | egsm, uhci->io_addr + USBCMD);
+                uhci_writew(uhci, USBCMD_FGR | USBCMD_CF | egsm, USBCMD);
                 spin_unlock_irq(&uhci->lock);
                 msleep(20);
                 spin_lock_irq(&uhci->lock);
@@ -401,10 +417,10 @@ __acquires(uhci->lock)
                         return;
 
                 /* End Global Resume and wait for EOP to be sent */
-                outw(USBCMD_CF, uhci->io_addr + USBCMD);
+                uhci_writew(uhci, USBCMD_CF, USBCMD);
                 mb();
                 udelay(4);
-                if (inw(uhci->io_addr + USBCMD) & USBCMD_FGR)
+                if (uhci_readw(uhci, USBCMD) & USBCMD_FGR)
                         dev_warn(uhci_dev(uhci), "FGR not stopped yet!\n");
         }
 
@@ -424,10 +440,10 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd)
          * interrupt cause.  Contrary to the UHCI specification, the
          * "HC Halted" status bit is persistent: it is RO, not R/WC.
          */
-        status = inw(uhci->io_addr + USBSTS);
+        status = uhci_readw(uhci, USBSTS);
         if (!(status & ~USBSTS_HCH))    /* shared interrupt, not mine */
                 return IRQ_NONE;
-        outw(status, uhci->io_addr + USBSTS);           /* Clear it */
+        uhci_writew(uhci, status, USBSTS);              /* Clear it */
 
         if (status & ~(USBSTS_USBINT | USBSTS_ERROR | USBSTS_RD)) {
                 if (status & USBSTS_HSE)
@@ -449,6 +465,7 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd)
                                         lprintk(errbuf);
                                 }
                                 uhci_hc_died(uhci);
+                                usb_hc_died(hcd);
 
                                 /* Force a callback in case there are
                                  * pending unlinks */
@@ -482,7 +499,7 @@ static void uhci_get_current_frame_number(struct uhci_hcd *uhci)
         if (!uhci->is_stopped) {
                 unsigned delta;
 
-                delta = (inw(uhci->io_addr + USBFRNUM) - uhci->frame_number) &
+                delta = (uhci_readw(uhci, USBFRNUM) - uhci->frame_number) &
                                 (UHCI_NUMFRAMES - 1);
                 uhci->frame_number += delta;
         }
@@ -519,61 +536,6 @@ static void release_uhci(struct uhci_hcd *uhci)
                         uhci->frame, uhci->frame_dma_handle);
 }
 
-static int uhci_init(struct usb_hcd *hcd)
-{
-        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
-        unsigned io_size = (unsigned) hcd->rsrc_len;
-        int port;
-
-        uhci->io_addr = (unsigned long) hcd->rsrc_start;
-
-        /* The UHCI spec says devices must have 2 ports, and goes on to say
-         * they may have more but gives no way to determine how many there
-         * are.  However according to the UHCI spec, Bit 7 of the port
-         * status and control register is always set to 1.  So we try to
-         * use this to our advantage.  Another common failure mode when
-         * a nonexistent register is addressed is to return all ones, so
-         * we test for that also.
-         */
-        for (port = 0; port < (io_size - USBPORTSC1) / 2; port++) {
-                unsigned int portstatus;
-
-                portstatus = inw(uhci->io_addr + USBPORTSC1 + (port * 2));
-                if (!(portstatus & 0x0080) || portstatus == 0xffff)
-                        break;
-        }
-        if (debug)
-                dev_info(uhci_dev(uhci), "detected %d ports\n", port);
-
-        /* Anything greater than 7 is weird so we'll ignore it. */
-        if (port > UHCI_RH_MAXCHILD) {
-                dev_info(uhci_dev(uhci), "port count misdetected? "
-                                "forcing to 2 ports\n");
-                port = 2;
-        }
-        uhci->rh_numports = port;
-
-        /* Kick BIOS off this hardware and reset if the controller
-         * isn't already safely quiescent.
-         */
-        check_and_reset_hc(uhci);
-        return 0;
-}
-
-/* Make sure the controller is quiescent and that we're not using it
- * any more.  This is mainly for the benefit of programs which, like kexec,
- * expect the hardware to be idle: not doing DMA or generating IRQs.
- *
- * This routine may be called in a damaged or failing kernel.  Hence we
- * do not acquire the spinlock before shutting down the controller.
- */
-static void uhci_shutdown(struct pci_dev *pdev)
-{
-        struct usb_hcd *hcd = pci_get_drvdata(pdev);
-
-        uhci_hc_died(hcd_to_uhci(hcd));
-}
-
 /*
  * Allocate a frame list, and then setup the skeleton
  *
@@ -790,86 +752,6 @@ static int uhci_rh_resume(struct usb_hcd *hcd)
         return rc;
 }
 
-static int uhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
-{
-        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
-        struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
-        int rc = 0;
-
-        dev_dbg(uhci_dev(uhci), "%s\n", __func__);
-
-        spin_lock_irq(&uhci->lock);
-        if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead)
-                goto done_okay;         /* Already suspended or dead */
-
-        if (uhci->rh_state > UHCI_RH_SUSPENDED) {
-                dev_warn(uhci_dev(uhci), "Root hub isn't suspended!\n");
-                rc = -EBUSY;
-                goto done;
-        };
-
-        /* All PCI host controllers are required to disable IRQ generation
-         * at the source, so we must turn off PIRQ.
-         */
-        pci_write_config_word(pdev, USBLEGSUP, 0);
-        clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
-
-        /* Enable platform-specific non-PME# wakeup */
-        if (do_wakeup) {
-                if (pdev->vendor == PCI_VENDOR_ID_INTEL)
-                        pci_write_config_byte(pdev, USBRES_INTEL,
-                                        USBPORT1EN | USBPORT2EN);
-        }
-
-done_okay:
-        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-done:
-        spin_unlock_irq(&uhci->lock);
-        return rc;
-}
-
-static int uhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
-{
-        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
-
-        dev_dbg(uhci_dev(uhci), "%s\n", __func__);
-
-        /* Since we aren't in D3 any more, it's safe to set this flag
-         * even if the controller was dead.
-         */
-        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-
-        spin_lock_irq(&uhci->lock);
-
-        /* Make sure resume from hibernation re-enumerates everything */
-        if (hibernated)
-                uhci_hc_died(uhci);
-
-        /* The firmware or a boot kernel may have changed the controller
-         * settings during a system wakeup.  Check it and reconfigure
-         * to avoid problems.
-         */
-        check_and_reset_hc(uhci);
-
-        /* If the controller was dead before, it's back alive now */
-        configure_hc(uhci);
-
-        /* Tell the core if the controller had to be reset */
-        if (uhci->rh_state == UHCI_RH_RESET)
-                usb_root_hub_lost_power(hcd->self.root_hub);
-
-        spin_unlock_irq(&uhci->lock);
-
-        /* If interrupts don't work and remote wakeup is enabled then
-         * the suspended root hub needs to be polled.
-         */
-        if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup)
-                set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
-
-        /* Does the root hub have a port wakeup pending? */
-        usb_hcd_poll_rh_status(hcd);
-        return 0;
-}
 #endif
 
 /* Wait until a particular device/endpoint's QH is idle, and free it */
@@ -907,67 +789,62 @@ static int uhci_hcd_get_frame_number(struct usb_hcd *hcd)
         /* Minimize latency by avoiding the spinlock */
         frame_number = uhci->frame_number;
         barrier();
-        delta = (inw(uhci->io_addr + USBFRNUM) - frame_number) &
+        delta = (uhci_readw(uhci, USBFRNUM) - frame_number) &
                         (UHCI_NUMFRAMES - 1);
         return frame_number + delta;
 }
 
-static const char hcd_name[] = "uhci_hcd";
-
-static const struct hc_driver uhci_driver = {
-        .description =          hcd_name,
-        .product_desc =         "UHCI Host Controller",
-        .hcd_priv_size =        sizeof(struct uhci_hcd),
-
-        /* Generic hardware linkage */
-        .irq =                  uhci_irq,
-        .flags =                HCD_USB11,
-
-        /* Basic lifecycle operations */
-        .reset =                uhci_init,
-        .start =                uhci_start,
-#ifdef CONFIG_PM
-        .pci_suspend =          uhci_pci_suspend,
-        .pci_resume =           uhci_pci_resume,
-        .bus_suspend =          uhci_rh_suspend,
-        .bus_resume =           uhci_rh_resume,
-#endif
-        .stop =                 uhci_stop,
+/* Determines number of ports on controller */
+static int uhci_count_ports(struct usb_hcd *hcd)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+        unsigned io_size = (unsigned) hcd->rsrc_len;
+        int port;
 
-        .urb_enqueue =          uhci_urb_enqueue,
-        .urb_dequeue =          uhci_urb_dequeue,
+        /* The UHCI spec says devices must have 2 ports, and goes on to say
+         * they may have more but gives no way to determine how many there
+         * are.  However according to the UHCI spec, Bit 7 of the port
+         * status and control register is always set to 1.  So we try to
+         * use this to our advantage.  Another common failure mode when
+         * a nonexistent register is addressed is to return all ones, so
+         * we test for that also.
+         */
+        for (port = 0; port < (io_size - USBPORTSC1) / 2; port++) {
+                unsigned int portstatus;
 
-        .endpoint_disable =     uhci_hcd_endpoint_disable,
-        .get_frame_number =     uhci_hcd_get_frame_number,
+                portstatus = uhci_readw(uhci, USBPORTSC1 + (port * 2));
+                if (!(portstatus & 0x0080) || portstatus == 0xffff)
+                        break;
+        }
+        if (debug)
+                dev_info(uhci_dev(uhci), "detected %d ports\n", port);
 
-        .hub_status_data =      uhci_hub_status_data,
-        .hub_control =          uhci_hub_control,
-};
+        /* Anything greater than 7 is weird so we'll ignore it. */
+        if (port > UHCI_RH_MAXCHILD) {
+                dev_info(uhci_dev(uhci), "port count misdetected? "
+                                "forcing to 2 ports\n");
+                port = 2;
+        }
 
-static const struct pci_device_id uhci_pci_ids[] = { {
-        /* handle any USB UHCI controller */
-        PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_UHCI, ~0),
-        .driver_data =  (unsigned long) &uhci_driver,
-        }, { /* end: all zeroes */ }
-};
+        return port;
+}
 
-MODULE_DEVICE_TABLE(pci, uhci_pci_ids);
+static const char hcd_name[] = "uhci_hcd";
 
-static struct pci_driver uhci_pci_driver = {
-        .name =         (char *)hcd_name,
-        .id_table =     uhci_pci_ids,
+#ifdef CONFIG_PCI
+#include "uhci-pci.c"
+#define PCI_DRIVER              uhci_pci_driver
+#endif
 
-        .probe =        usb_hcd_pci_probe,
-        .remove =       usb_hcd_pci_remove,
-        .shutdown =     uhci_shutdown,
+#ifdef CONFIG_SPARC_LEON
+#include "uhci-grlib.c"
+#define PLATFORM_DRIVER         uhci_grlib_driver
+#endif
 
-#ifdef CONFIG_PM_SLEEP
-        .driver =       {
-                .pm =   &usb_hcd_pci_pm_ops
-        },
+#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER)
+#error "missing bus glue for uhci-hcd"
 #endif
-};
- 
+
 static int __init uhci_hcd_init(void)
 {
         int retval = -ENOMEM;
@@ -993,13 +870,27 @@ static int __init uhci_hcd_init(void)
         if (!uhci_up_cachep)
                 goto up_failed;
 
-        retval = pci_register_driver(&uhci_pci_driver);
-        if (retval)
-                goto init_failed;
+#ifdef PLATFORM_DRIVER
+        retval = platform_driver_register(&PLATFORM_DRIVER);
+        if (retval < 0)
+                goto clean0;
+#endif
+
+#ifdef PCI_DRIVER
+        retval = pci_register_driver(&PCI_DRIVER);
+        if (retval < 0)
+                goto clean1;
+#endif
 
         return 0;
 
-init_failed:
+#ifdef PCI_DRIVER
+clean1:
+#endif
+#ifdef PLATFORM_DRIVER
+        platform_driver_unregister(&PLATFORM_DRIVER);
+clean0:
+#endif
         kmem_cache_destroy(uhci_up_cachep);
 
 up_failed:
@@ -1016,7 +907,12 @@ errbuf_failed:
 
 static void __exit uhci_hcd_cleanup(void) 
 {
-        pci_unregister_driver(&uhci_pci_driver);
+#ifdef PLATFORM_DRIVER
+        platform_driver_unregister(&PLATFORM_DRIVER);
+#endif
+#ifdef PCI_DRIVER
+        pci_unregister_driver(&PCI_DRIVER);
+#endif
         kmem_cache_destroy(uhci_up_cachep);
         debugfs_remove(uhci_debugfs_root);
         kfree(errbuf);
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index 49bf2790f9c2..a4e64d08f020 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -380,6 +380,9 @@ struct uhci_hcd {
         /* Grabbed from PCI */
         unsigned long io_addr;
 
+        /* Used when registers are memory mapped */
+        void __iomem *regs;
+
         struct dma_pool *qh_pool;
         struct dma_pool *td_pool;
 
@@ -415,6 +418,10 @@ struct uhci_hcd {
 
         struct timer_list fsbr_timer;           /* For turning off FBSR */
 
+        /* Silicon quirks */
+        unsigned int oc_low:1;                  /* OverCurrent bit active low */
+        unsigned int wait_for_hp:1;             /* Wait for HP port reset */
+
         /* Support for port suspend/resume/reset */
         unsigned long port_c_suspend;           /* Bit-arrays of ports */
         unsigned long resuming_ports;
@@ -429,6 +436,16 @@ struct uhci_hcd {
 
         int total_load;                         /* Sum of array values */
         short load[MAX_PHASE];                  /* Periodic allocations */
+
+        /* Reset host controller */
+        void    (*reset_hc) (struct uhci_hcd *uhci);
+        int     (*check_and_reset_hc) (struct uhci_hcd *uhci);
+        /* configure_hc should perform arch specific settings, if needed */
+        void    (*configure_hc) (struct uhci_hcd *uhci);
+        /* Check for broken resume detect interrupts */
+        int     (*resume_detect_interrupts_are_broken) (struct uhci_hcd *uhci);
+        /* Check for broken global suspend */
+        int     (*global_suspend_mode_is_broken) (struct uhci_hcd *uhci);
 };
 
 /* Convert between a usb_hcd pointer and the corresponding uhci_hcd */
@@ -467,4 +484,96 @@ struct urb_priv {
 #define PCI_VENDOR_ID_GENESYS           0x17a0
 #define PCI_DEVICE_ID_GL880S_UHCI       0x8083
 
+/*
+ * Functions used to access controller registers. The UCHI spec says that host
+ * controller I/O registers are mapped into PCI I/O space. For non-PCI hosts
+ * we use memory mapped registers.
+ */
+
+#if !defined(CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC)
+/* Support PCI only */
+static inline u32 uhci_readl(struct uhci_hcd *uhci, int reg)
+{
+        return inl(uhci->io_addr + reg);
+}
+
+static inline void uhci_writel(struct uhci_hcd *uhci, u32 val, int reg)
+{
+        outl(val, uhci->io_addr + reg);
+}
+
+static inline u16 uhci_readw(struct uhci_hcd *uhci, int reg)
+{
+        return inw(uhci->io_addr + reg);
+}
+
+static inline void uhci_writew(struct uhci_hcd *uhci, u16 val, int reg)
+{
+        outw(val, uhci->io_addr + reg);
+}
+
+static inline u8 uhci_readb(struct uhci_hcd *uhci, int reg)
+{
+        return inb(uhci->io_addr + reg);
+}
+
+static inline void uhci_writeb(struct uhci_hcd *uhci, u8 val, int reg)
+{
+        outb(val, uhci->io_addr + reg);
+}
+
+#else
+/* Support PCI and non-PCI host controllers */
+
+#define uhci_has_pci_registers(u)       ((u)->io_addr != 0)
+
+static inline u32 uhci_readl(struct uhci_hcd *uhci, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                return inl(uhci->io_addr + reg);
+        else
+                return readl(uhci->regs + reg);
+}
+
+static inline void uhci_writel(struct uhci_hcd *uhci, u32 val, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                outl(val, uhci->io_addr + reg);
+        else
+                writel(val, uhci->regs + reg);
+}
+
+static inline u16 uhci_readw(struct uhci_hcd *uhci, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                return inw(uhci->io_addr + reg);
+        else
+                return readw(uhci->regs + reg);
+}
+
+static inline void uhci_writew(struct uhci_hcd *uhci, u16 val, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                outw(val, uhci->io_addr + reg);
+        else
+                writew(val, uhci->regs + reg);
+}
+
+static inline u8 uhci_readb(struct uhci_hcd *uhci, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                return inb(uhci->io_addr + reg);
+        else
+                return readb(uhci->regs + reg);
+}
+
+static inline void uhci_writeb(struct uhci_hcd *uhci, u8 val, int reg)
+{
+        if (uhci_has_pci_registers(uhci))
+                outb(val, uhci->io_addr + reg);
+        else
+                writeb(val, uhci->regs + reg);
+}
+#endif /* !defined(CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC) */
+
 #endif
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 6d59c0f77f25..045cde4cbc3d 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -44,7 +44,7 @@ static int any_ports_active(struct uhci_hcd *uhci)
         int port;
 
         for (port = 0; port < uhci->rh_numports; ++port) {
-                if ((inw(uhci->io_addr + USBPORTSC1 + port * 2) &
+                if ((uhci_readw(uhci, USBPORTSC1 + port * 2) &
                                 (USBPORTSC_CCS | RWC_BITS)) ||
                                 test_bit(port, &uhci->port_c_suspend))
                         return 1;
@@ -68,7 +68,7 @@ static inline int get_hub_status_data(struct uhci_hcd *uhci, char *buf)
 
         *buf = 0;
         for (port = 0; port < uhci->rh_numports; ++port) {
-                if ((inw(uhci->io_addr + USBPORTSC1 + port * 2) & mask) ||
+                if ((uhci_readw(uhci, USBPORTSC1 + port * 2) & mask) ||
                                 test_bit(port, &uhci->port_c_suspend))
                         *buf |= (1 << (port + 1));
         }
@@ -78,17 +78,17 @@ static inline int get_hub_status_data(struct uhci_hcd *uhci, char *buf)
 #define OK(x)                   len = (x); break
 
 #define CLR_RH_PORTSTAT(x) \
-        status = inw(port_addr); \
+        status = uhci_readw(uhci, port_addr);   \
         status &= ~(RWC_BITS|WZ_BITS); \
         status &= ~(x); \
         status |= RWC_BITS & (x); \
-        outw(status, port_addr)
+        uhci_writew(uhci, status, port_addr)
 
 #define SET_RH_PORTSTAT(x) \
-        status = inw(port_addr); \
+        status = uhci_readw(uhci, port_addr);   \
         status |= (x); \
         status &= ~(RWC_BITS|WZ_BITS); \
-        outw(status, port_addr)
+        uhci_writew(uhci, status, port_addr)
 
 /* UHCI controllers don't automatically stop resume signalling after 20 msec,
  * so we have to poll and check timeouts in order to take care of it.
@@ -99,7 +99,7 @@ static void uhci_finish_suspend(struct uhci_hcd *uhci, int port,
         int status;
         int i;
 
-        if (inw(port_addr) & SUSPEND_BITS) {
+        if (uhci_readw(uhci, port_addr) & SUSPEND_BITS) {
                 CLR_RH_PORTSTAT(SUSPEND_BITS);
                 if (test_bit(port, &uhci->resuming_ports))
                         set_bit(port, &uhci->port_c_suspend);
@@ -110,7 +110,7 @@ static void uhci_finish_suspend(struct uhci_hcd *uhci, int port,
                  * Experiments show that some controllers take longer, so
                  * we'll poll for completion. */
                 for (i = 0; i < 10; ++i) {
-                        if (!(inw(port_addr) & SUSPEND_BITS))
+                        if (!(uhci_readw(uhci, port_addr) & SUSPEND_BITS))
                                 break;
                         udelay(1);
                 }
@@ -121,12 +121,12 @@ static void uhci_finish_suspend(struct uhci_hcd *uhci, int port,
 /* Wait for the UHCI controller in HP's iLO2 server management chip.
  * It can take up to 250 us to finish a reset and set the CSC bit.
  */
-static void wait_for_HP(unsigned long port_addr)
+static void wait_for_HP(struct uhci_hcd *uhci, unsigned long port_addr)
 {
         int i;
 
         for (i = 10; i < 250; i += 10) {
-                if (inw(port_addr) & USBPORTSC_CSC)
+                if (uhci_readw(uhci, port_addr) & USBPORTSC_CSC)
                         return;
                 udelay(10);
         }
@@ -140,8 +140,8 @@ static void uhci_check_ports(struct uhci_hcd *uhci)
         int status;
 
         for (port = 0; port < uhci->rh_numports; ++port) {
-                port_addr = uhci->io_addr + USBPORTSC1 + 2 * port;
-                status = inw(port_addr);
+                port_addr = USBPORTSC1 + 2 * port;
+                status = uhci_readw(uhci, port_addr);
                 if (unlikely(status & USBPORTSC_PR)) {
                         if (time_after_eq(jiffies, uhci->ports_timeout)) {
                                 CLR_RH_PORTSTAT(USBPORTSC_PR);
@@ -149,9 +149,8 @@ static void uhci_check_ports(struct uhci_hcd *uhci)
 
                                 /* HP's server management chip requires
                                  * a longer delay. */
-                                if (to_pci_dev(uhci_dev(uhci))->vendor ==
-                                                PCI_VENDOR_ID_HP)
-                                        wait_for_HP(port_addr);
+                                if (uhci->wait_for_hp)
+                                        wait_for_HP(uhci, port_addr);
 
                                 /* If the port was enabled before, turning
                                  * reset on caused a port enable change.
@@ -242,7 +241,7 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
         int status, lstatus, retval = 0, len = 0;
         unsigned int port = wIndex - 1;
-        unsigned long port_addr = uhci->io_addr + USBPORTSC1 + 2 * port;
+        unsigned long port_addr = USBPORTSC1 + 2 * port;
         u16 wPortChange, wPortStatus;
         unsigned long flags;
 
@@ -260,14 +259,13 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         goto err;
 
                 uhci_check_ports(uhci);
-                status = inw(port_addr);
+                status = uhci_readw(uhci, port_addr);
 
                 /* Intel controllers report the OverCurrent bit active on.
                  * VIA controllers report it active off, so we'll adjust the
                  * bit value.  (It's not standardized in the UHCI spec.)
                  */
-                if (to_pci_dev(hcd->self.controller)->vendor ==
-                                PCI_VENDOR_ID_VIA)
+                if (uhci->oc_low)
                         status ^= USBPORTSC_OC;
 
                 /* UHCI doesn't support C_RESET (always false) */
@@ -358,7 +356,7 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         CLR_RH_PORTSTAT(USBPORTSC_PEC);
                         OK(0);
                 case USB_PORT_FEAT_SUSPEND:
-                        if (!(inw(port_addr) & USBPORTSC_SUSP)) {
+                        if (!(uhci_readw(uhci, port_addr) & USBPORTSC_SUSP)) {
 
                                 /* Make certain the port isn't suspended */
                                 uhci_finish_suspend(uhci, port, port_addr);
@@ -370,7 +368,8 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                  * if the port is disabled.  When this happens
                                  * just skip the Resume signalling.
                                  */
-                                if (!(inw(port_addr) & USBPORTSC_RD))
+                                if (!(uhci_readw(uhci, port_addr) &
+                                                USBPORTSC_RD))
                                         uhci_finish_suspend(uhci, port,
                                                         port_addr);
                                 else
diff --git a/drivers/usb/host/uhci-pci.c b/drivers/usb/host/uhci-pci.c
new file mode 100644
index 000000000000..c300bd2f7d1c
--- /dev/null
+++ b/drivers/usb/host/uhci-pci.c
@@ -0,0 +1,301 @@
+/*
+ * UHCI HCD (Host Controller Driver) PCI Bus Glue.
+ *
+ * Extracted from uhci-hcd.c:
+ * Maintainer: Alan Stern <stern@rowland.harvard.edu>
+ *
+ * (C) Copyright 1999 Linus Torvalds
+ * (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com
+ * (C) Copyright 1999 Randy Dunlap
+ * (C) Copyright 1999 Georg Acher, acher@in.tum.de
+ * (C) Copyright 1999 Deti Fliegl, deti@fliegl.de
+ * (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch
+ * (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at
+ * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface
+ *               support from usb-ohci.c by Adam Richter, adam@yggdrasil.com).
+ * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c)
+ * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
+ */
+
+#include "pci-quirks.h"
+
+/*
+ * Make sure the controller is completely inactive, unable to
+ * generate interrupts or do DMA.
+ */
+static void uhci_pci_reset_hc(struct uhci_hcd *uhci)
+{
+        uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr);
+}
+
+/*
+ * Initialize a controller that was newly discovered or has just been
+ * resumed.  In either case we can't be sure of its previous state.
+ *
+ * Returns: 1 if the controller was reset, 0 otherwise.
+ */
+static int uhci_pci_check_and_reset_hc(struct uhci_hcd *uhci)
+{
+        return uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)),
+                                uhci->io_addr);
+}
+
+/*
+ * Store the basic register settings needed by the controller.
+ * This function is called at the end of configure_hc in uhci-hcd.c.
+ */
+static void uhci_pci_configure_hc(struct uhci_hcd *uhci)
+{
+        struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
+
+        /* Enable PIRQ */
+        pci_write_config_word(pdev, USBLEGSUP, USBLEGSUP_DEFAULT);
+
+        /* Disable platform-specific non-PME# wakeup */
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL)
+                pci_write_config_byte(pdev, USBRES_INTEL, 0);
+}
+
+static int uhci_pci_resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
+{
+        int port;
+
+        switch (to_pci_dev(uhci_dev(uhci))->vendor) {
+        default:
+                break;
+
+        case PCI_VENDOR_ID_GENESYS:
+                /* Genesys Logic's GL880S controllers don't generate
+                 * resume-detect interrupts.
+                 */
+                return 1;
+
+        case PCI_VENDOR_ID_INTEL:
+                /* Some of Intel's USB controllers have a bug that causes
+                 * resume-detect interrupts if any port has an over-current
+                 * condition.  To make matters worse, some motherboards
+                 * hardwire unused USB ports' over-current inputs active!
+                 * To prevent problems, we will not enable resume-detect
+                 * interrupts if any ports are OC.
+                 */
+                for (port = 0; port < uhci->rh_numports; ++port) {
+                        if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
+                                        USBPORTSC_OC)
+                                return 1;
+                }
+                break;
+        }
+        return 0;
+}
+
+static int uhci_pci_global_suspend_mode_is_broken(struct uhci_hcd *uhci)
+{
+        int port;
+        const char *sys_info;
+        static const char bad_Asus_board[] = "A7V8X";
+
+        /* One of Asus's motherboards has a bug which causes it to
+         * wake up immediately from suspend-to-RAM if any of the ports
+         * are connected.  In such cases we will not set EGSM.
+         */
+        sys_info = dmi_get_system_info(DMI_BOARD_NAME);
+        if (sys_info && !strcmp(sys_info, bad_Asus_board)) {
+                for (port = 0; port < uhci->rh_numports; ++port) {
+                        if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
+                                        USBPORTSC_CCS)
+                                return 1;
+                }
+        }
+
+        return 0;
+}
+
+static int uhci_pci_init(struct usb_hcd *hcd)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+
+        uhci->io_addr = (unsigned long) hcd->rsrc_start;
+
+        uhci->rh_numports = uhci_count_ports(hcd);
+
+        /* Intel controllers report the OverCurrent bit active on.
+         * VIA controllers report it active off, so we'll adjust the
+         * bit value.  (It's not standardized in the UHCI spec.)
+         */
+        if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_VIA)
+                uhci->oc_low = 1;
+
+        /* HP's server management chip requires a longer port reset delay. */
+        if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_HP)
+                uhci->wait_for_hp = 1;
+
+        /* Set up pointers to PCI-specific functions */
+        uhci->reset_hc = uhci_pci_reset_hc;
+        uhci->check_and_reset_hc = uhci_pci_check_and_reset_hc;
+        uhci->configure_hc = uhci_pci_configure_hc;
+        uhci->resume_detect_interrupts_are_broken =
+                uhci_pci_resume_detect_interrupts_are_broken;
+        uhci->global_suspend_mode_is_broken =
+                uhci_pci_global_suspend_mode_is_broken;
+
+
+        /* Kick BIOS off this hardware and reset if the controller
+         * isn't already safely quiescent.
+         */
+        check_and_reset_hc(uhci);
+        return 0;
+}
+
+/* Make sure the controller is quiescent and that we're not using it
+ * any more.  This is mainly for the benefit of programs which, like kexec,
+ * expect the hardware to be idle: not doing DMA or generating IRQs.
+ *
+ * This routine may be called in a damaged or failing kernel.  Hence we
+ * do not acquire the spinlock before shutting down the controller.
+ */
+static void uhci_shutdown(struct pci_dev *pdev)
+{
+        struct usb_hcd *hcd = pci_get_drvdata(pdev);
+
+        uhci_hc_died(hcd_to_uhci(hcd));
+}
+
+#ifdef CONFIG_PM
+
+static int uhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+        struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
+        int rc = 0;
+
+        dev_dbg(uhci_dev(uhci), "%s\n", __func__);
+
+        spin_lock_irq(&uhci->lock);
+        if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead)
+                goto done_okay;         /* Already suspended or dead */
+
+        if (uhci->rh_state > UHCI_RH_SUSPENDED) {
+                dev_warn(uhci_dev(uhci), "Root hub isn't suspended!\n");
+                rc = -EBUSY;
+                goto done;
+        };
+
+        /* All PCI host controllers are required to disable IRQ generation
+         * at the source, so we must turn off PIRQ.
+         */
+        pci_write_config_word(pdev, USBLEGSUP, 0);
+        clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+
+        /* Enable platform-specific non-PME# wakeup */
+        if (do_wakeup) {
+                if (pdev->vendor == PCI_VENDOR_ID_INTEL)
+                        pci_write_config_byte(pdev, USBRES_INTEL,
+                                        USBPORT1EN | USBPORT2EN);
+        }
+
+done_okay:
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+done:
+        spin_unlock_irq(&uhci->lock);
+        return rc;
+}
+
+static int uhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+
+        dev_dbg(uhci_dev(uhci), "%s\n", __func__);
+
+        /* Since we aren't in D3 any more, it's safe to set this flag
+         * even if the controller was dead.
+         */
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        spin_lock_irq(&uhci->lock);
+
+        /* Make sure resume from hibernation re-enumerates everything */
+        if (hibernated) {
+                uhci->reset_hc(uhci);
+                finish_reset(uhci);
+        }
+
+        /* The firmware may have changed the controller settings during
+         * a system wakeup.  Check it and reconfigure to avoid problems.
+         */
+        else {
+                check_and_reset_hc(uhci);
+        }
+        configure_hc(uhci);
+
+        /* Tell the core if the controller had to be reset */
+        if (uhci->rh_state == UHCI_RH_RESET)
+                usb_root_hub_lost_power(hcd->self.root_hub);
+
+        spin_unlock_irq(&uhci->lock);
+
+        /* If interrupts don't work and remote wakeup is enabled then
+         * the suspended root hub needs to be polled.
+         */
+        if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup)
+                set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+
+        /* Does the root hub have a port wakeup pending? */
+        usb_hcd_poll_rh_status(hcd);
+        return 0;
+}
+
+#endif
+
+static const struct hc_driver uhci_driver = {
+        .description =          hcd_name,
+        .product_desc =         "UHCI Host Controller",
+        .hcd_priv_size =        sizeof(struct uhci_hcd),
+
+        /* Generic hardware linkage */
+        .irq =                  uhci_irq,
+        .flags =                HCD_USB11,
+
+        /* Basic lifecycle operations */
+        .reset =                uhci_pci_init,
+        .start =                uhci_start,
+#ifdef CONFIG_PM
+        .pci_suspend =          uhci_pci_suspend,
+        .pci_resume =           uhci_pci_resume,
+        .bus_suspend =          uhci_rh_suspend,
+        .bus_resume =           uhci_rh_resume,
+#endif
+        .stop =                 uhci_stop,
+
+        .urb_enqueue =          uhci_urb_enqueue,
+        .urb_dequeue =          uhci_urb_dequeue,
+
+        .endpoint_disable =     uhci_hcd_endpoint_disable,
+        .get_frame_number =     uhci_hcd_get_frame_number,
+
+        .hub_status_data =      uhci_hub_status_data,
+        .hub_control =          uhci_hub_control,
+};
+
+static DEFINE_PCI_DEVICE_TABLE(uhci_pci_ids) = { {
+        /* handle any USB UHCI controller */
+        PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_UHCI, ~0),
+        .driver_data =  (unsigned long) &uhci_driver,
+        }, { /* end: all zeroes */ }
+};
+
+MODULE_DEVICE_TABLE(pci, uhci_pci_ids);
+
+static struct pci_driver uhci_pci_driver = {
+        .name =         (char *)hcd_name,
+        .id_table =     uhci_pci_ids,
+
+        .probe =        usb_hcd_pci_probe,
+        .remove =       usb_hcd_pci_remove,
+        .shutdown =     uhci_shutdown,
+
+#ifdef CONFIG_PM_SLEEP
+        .driver =       {
+                .pm =   &usb_hcd_pci_pm_ops
+        },
+#endif
+};
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index 0231814a97a5..2e0486178dbe 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -147,7 +147,7 @@ static void xhci_print_op_regs(struct xhci_hcd *xhci)
 
 static void xhci_print_ports(struct xhci_hcd *xhci)
 {
-        u32 __iomem *addr;
+        __le32 __iomem *addr;
         int i, j;
         int ports;
         char *names[NUM_PORT_REGS] = {
@@ -253,27 +253,27 @@ void xhci_print_trb_offsets(struct xhci_hcd *xhci, union xhci_trb *trb)
 void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
 {
         u64     address;
-        u32     type = xhci_readl(xhci, &trb->link.control) & TRB_TYPE_BITMASK;
+        u32     type = le32_to_cpu(trb->link.control) & TRB_TYPE_BITMASK;
 
         switch (type) {
         case TRB_TYPE(TRB_LINK):
                 xhci_dbg(xhci, "Link TRB:\n");
                 xhci_print_trb_offsets(xhci, trb);
 
-                address = trb->link.segment_ptr;
+                address = le64_to_cpu(trb->link.segment_ptr);
                 xhci_dbg(xhci, "Next ring segment DMA address = 0x%llx\n", address);
 
                 xhci_dbg(xhci, "Interrupter target = 0x%x\n",
-                                GET_INTR_TARGET(trb->link.intr_target));
+                         GET_INTR_TARGET(le32_to_cpu(trb->link.intr_target)));
                 xhci_dbg(xhci, "Cycle bit = %u\n",
-                                (unsigned int) (trb->link.control & TRB_CYCLE));
+                         (unsigned int) (le32_to_cpu(trb->link.control) & TRB_CYCLE));
                 xhci_dbg(xhci, "Toggle cycle bit = %u\n",
-                                (unsigned int) (trb->link.control & LINK_TOGGLE));
+                         (unsigned int) (le32_to_cpu(trb->link.control) & LINK_TOGGLE));
                 xhci_dbg(xhci, "No Snoop bit = %u\n",
-                                (unsigned int) (trb->link.control & TRB_NO_SNOOP));
+                         (unsigned int) (le32_to_cpu(trb->link.control) & TRB_NO_SNOOP));
                 break;
         case TRB_TYPE(TRB_TRANSFER):
-                address = trb->trans_event.buffer;
+                address = le64_to_cpu(trb->trans_event.buffer);
                 /*
                  * FIXME: look at flags to figure out if it's an address or if
                  * the data is directly in the buffer field.
@@ -281,11 +281,12 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
                 xhci_dbg(xhci, "DMA address or buffer contents= %llu\n", address);
                 break;
         case TRB_TYPE(TRB_COMPLETION):
-                address = trb->event_cmd.cmd_trb;
+                address = le64_to_cpu(trb->event_cmd.cmd_trb);
                 xhci_dbg(xhci, "Command TRB pointer = %llu\n", address);
                 xhci_dbg(xhci, "Completion status = %u\n",
-                                (unsigned int) GET_COMP_CODE(trb->event_cmd.status));
-                xhci_dbg(xhci, "Flags = 0x%x\n", (unsigned int) trb->event_cmd.flags);
+                         (unsigned int) GET_COMP_CODE(le32_to_cpu(trb->event_cmd.status)));
+                xhci_dbg(xhci, "Flags = 0x%x\n",
+                         (unsigned int) le32_to_cpu(trb->event_cmd.flags));
                 break;
         default:
                 xhci_dbg(xhci, "Unknown TRB with TRB type ID %u\n",
@@ -311,16 +312,16 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb)
 void xhci_debug_segment(struct xhci_hcd *xhci, struct xhci_segment *seg)
 {
         int i;
-        u32 addr = (u32) seg->dma;
+        u64 addr = seg->dma;
         union xhci_trb *trb = seg->trbs;
 
         for (i = 0; i < TRBS_PER_SEGMENT; ++i) {
                 trb = &seg->trbs[i];
-                xhci_dbg(xhci, "@%08x %08x %08x %08x %08x\n", addr,
-                                lower_32_bits(trb->link.segment_ptr),
-                                upper_32_bits(trb->link.segment_ptr),
-                                (unsigned int) trb->link.intr_target,
-                                (unsigned int) trb->link.control);
+                xhci_dbg(xhci, "@%016llx %08x %08x %08x %08x\n", addr,
+                         (u32)lower_32_bits(le64_to_cpu(trb->link.segment_ptr)),
+                         (u32)upper_32_bits(le64_to_cpu(trb->link.segment_ptr)),
+                         (unsigned int) le32_to_cpu(trb->link.intr_target),
+                         (unsigned int) le32_to_cpu(trb->link.control));
                 addr += sizeof(*trb);
         }
 }
@@ -391,18 +392,18 @@ void xhci_dbg_ep_rings(struct xhci_hcd *xhci,
 
 void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst)
 {
-        u32 addr = (u32) erst->erst_dma_addr;
+        u64 addr = erst->erst_dma_addr;
         int i;
         struct xhci_erst_entry *entry;
 
         for (i = 0; i < erst->num_entries; ++i) {
                 entry = &erst->entries[i];
-                xhci_dbg(xhci, "@%08x %08x %08x %08x %08x\n",
-                                (unsigned int) addr,
-                                lower_32_bits(entry->seg_addr),
-                                upper_32_bits(entry->seg_addr),
-                                (unsigned int) entry->seg_size,
-                                (unsigned int) entry->rsvd);
+                xhci_dbg(xhci, "@%016llx %08x %08x %08x %08x\n",
+                         addr,
+                         lower_32_bits(le64_to_cpu(entry->seg_addr)),
+                         upper_32_bits(le64_to_cpu(entry->seg_addr)),
+                         (unsigned int) le32_to_cpu(entry->seg_size),
+                         (unsigned int) le32_to_cpu(entry->rsvd));
                 addr += sizeof(*entry);
         }
 }
@@ -436,7 +437,7 @@ char *xhci_get_slot_state(struct xhci_hcd *xhci,
 {
         struct xhci_slot_ctx *slot_ctx = xhci_get_slot_ctx(xhci, ctx);
 
-        switch (GET_SLOT_STATE(slot_ctx->dev_state)) {
+        switch (GET_SLOT_STATE(le32_to_cpu(slot_ctx->dev_state))) {
         case 0:
                 return "enabled/disabled";
         case 1:
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 73f75d26436c..a56963736018 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -50,7 +50,7 @@ static void xhci_common_hub_descriptor(struct xhci_hcd *xhci,
         temp |= 0x0008;
         /* Bits 6:5 - no TTs in root ports */
         /* Bit  7 - no port indicators */
-        desc->wHubCharacteristics = (__force __u16) cpu_to_le16(temp);
+        desc->wHubCharacteristics = cpu_to_le16(temp);
 }
 
 /* Fill in the USB 2.0 roothub descriptor */
@@ -314,7 +314,7 @@ void xhci_ring_device(struct xhci_hcd *xhci, int slot_id)
 }
 
 static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
-                u16 wIndex, u32 __iomem *addr, u32 port_status)
+                u16 wIndex, __le32 __iomem *addr, u32 port_status)
 {
         /* Don't allow the USB core to disable SuperSpeed ports. */
         if (hcd->speed == HCD_USB3) {
@@ -331,7 +331,7 @@ static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
 }
 
 static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
-                u16 wIndex, u32 __iomem *addr, u32 port_status)
+                u16 wIndex, __le32 __iomem *addr, u32 port_status)
 {
         char *port_change_bit;
         u32 status;
@@ -341,6 +341,10 @@ static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
                 status = PORT_RC;
                 port_change_bit = "reset";
                 break;
+        case USB_PORT_FEAT_C_BH_PORT_RESET:
+                status = PORT_WRC;
+                port_change_bit = "warm(BH) reset";
+                break;
         case USB_PORT_FEAT_C_CONNECTION:
                 status = PORT_CSC;
                 port_change_bit = "connect";
@@ -357,6 +361,10 @@ static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
                 status = PORT_PLC;
                 port_change_bit = "suspend/resume";
                 break;
+        case USB_PORT_FEAT_C_PORT_LINK_STATE:
+                status = PORT_PLC;
+                port_change_bit = "link state";
+                break;
         default:
                 /* Should never happen */
                 return;
@@ -376,9 +384,10 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
         unsigned long flags;
         u32 temp, temp1, status;
         int retval = 0;
-        u32 __iomem **port_array;
+        __le32 __iomem **port_array;
         int slot_id;
         struct xhci_bus_state *bus_state;
+        u16 link_state = 0;
 
         if (hcd->speed == HCD_USB3) {
                 ports = xhci->num_usb3_ports;
@@ -422,9 +431,6 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 }
                 xhci_dbg(xhci, "get port status, actual port %d status  = 0x%x\n", wIndex, temp);
 
-                /* FIXME - should we return a port status value like the USB
-                 * 3.0 external hubs do?
-                 */
                 /* wPortChange bits */
                 if (temp & PORT_CSC)
                         status |= USB_PORT_STAT_C_CONNECTION << 16;
@@ -432,13 +438,21 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         status |= USB_PORT_STAT_C_ENABLE << 16;
                 if ((temp & PORT_OCC))
                         status |= USB_PORT_STAT_C_OVERCURRENT << 16;
-                /*
-                 * FIXME ignoring reset and USB 2.1/3.0 specific
-                 * changes
-                 */
-                if ((temp & PORT_PLS_MASK) == XDEV_U3
-                        && (temp & PORT_POWER))
-                        status |= 1 << USB_PORT_FEAT_SUSPEND;
+                if ((temp & PORT_RC))
+                        status |= USB_PORT_STAT_C_RESET << 16;
+                /* USB3.0 only */
+                if (hcd->speed == HCD_USB3) {
+                        if ((temp & PORT_PLC))
+                                status |= USB_PORT_STAT_C_LINK_STATE << 16;
+                        if ((temp & PORT_WRC))
+                                status |= USB_PORT_STAT_C_BH_RESET << 16;
+                }
+
+                if (hcd->speed != HCD_USB3) {
+                        if ((temp & PORT_PLS_MASK) == XDEV_U3
+                                        && (temp & PORT_POWER))
+                                status |= USB_PORT_STAT_SUSPEND;
+                }
                 if ((temp & PORT_PLS_MASK) == XDEV_RESUME) {
                         if ((temp & PORT_RESET) || !(temp & PORT_PE))
                                 goto error;
@@ -469,7 +483,8 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         && (temp & PORT_POWER)
                         && (bus_state->suspended_ports & (1 << wIndex))) {
                         bus_state->suspended_ports &= ~(1 << wIndex);
-                        bus_state->port_c_suspend |= 1 << wIndex;
+                        if (hcd->speed != HCD_USB3)
+                                bus_state->port_c_suspend |= 1 << wIndex;
                 }
                 if (temp & PORT_CONNECT) {
                         status |= USB_PORT_STAT_CONNECTION;
@@ -481,14 +496,28 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         status |= USB_PORT_STAT_OVERCURRENT;
                 if (temp & PORT_RESET)
                         status |= USB_PORT_STAT_RESET;
-                if (temp & PORT_POWER)
-                        status |= USB_PORT_STAT_POWER;
+                if (temp & PORT_POWER) {
+                        if (hcd->speed == HCD_USB3)
+                                status |= USB_SS_PORT_STAT_POWER;
+                        else
+                                status |= USB_PORT_STAT_POWER;
+                }
+                /* Port Link State */
+                if (hcd->speed == HCD_USB3) {
+                        /* resume state is a xHCI internal state.
+                         * Do not report it to usb core.
+                         */
+                        if ((temp & PORT_PLS_MASK) != XDEV_RESUME)
+                                status |= (temp & PORT_PLS_MASK);
+                }
                 if (bus_state->port_c_suspend & (1 << wIndex))
                         status |= 1 << USB_PORT_FEAT_C_SUSPEND;
                 xhci_dbg(xhci, "Get port status returned 0x%x\n", status);
                 put_unaligned(cpu_to_le32(status), (__le32 *) buf);
                 break;
         case SetPortFeature:
+                if (wValue == USB_PORT_FEAT_LINK_STATE)
+                        link_state = (wIndex & 0xff00) >> 3;
                 wIndex &= 0xff;
                 if (!wIndex || wIndex > ports)
                         goto error;
@@ -537,6 +566,44 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         temp = xhci_readl(xhci, port_array[wIndex]);
                         bus_state->suspended_ports |= 1 << wIndex;
                         break;
+                case USB_PORT_FEAT_LINK_STATE:
+                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        /* Software should not attempt to set
+                         * port link state above '5' (Rx.Detect) and the port
+                         * must be enabled.
+                         */
+                        if ((temp & PORT_PE) == 0 ||
+                                (link_state > USB_SS_PORT_LS_RX_DETECT)) {
+                                xhci_warn(xhci, "Cannot set link state.\n");
+                                goto error;
+                        }
+
+                        if (link_state == USB_SS_PORT_LS_U3) {
+                                slot_id = xhci_find_slot_id_by_port(hcd, xhci,
+                                                wIndex + 1);
+                                if (slot_id) {
+                                        /* unlock to execute stop endpoint
+                                         * commands */
+                                        spin_unlock_irqrestore(&xhci->lock,
+                                                                flags);
+                                        xhci_stop_device(xhci, slot_id, 1);
+                                        spin_lock_irqsave(&xhci->lock, flags);
+                                }
+                        }
+
+                        temp = xhci_port_state_to_neutral(temp);
+                        temp &= ~PORT_PLS_MASK;
+                        temp |= PORT_LINK_STROBE | link_state;
+                        xhci_writel(xhci, temp, port_array[wIndex]);
+
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        msleep(20); /* wait device to enter */
+                        spin_lock_irqsave(&xhci->lock, flags);
+
+                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        if (link_state == USB_SS_PORT_LS_U3)
+                                bus_state->suspended_ports |= 1 << wIndex;
+                        break;
                 case USB_PORT_FEAT_POWER:
                         /*
                          * Turn on ports, even if there isn't per-port switching.
@@ -557,6 +624,12 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         temp = xhci_readl(xhci, port_array[wIndex]);
                         xhci_dbg(xhci, "set port reset, actual port %d status  = 0x%x\n", wIndex, temp);
                         break;
+                case USB_PORT_FEAT_BH_PORT_RESET:
+                        temp |= PORT_WR;
+                        xhci_writel(xhci, temp, port_array[wIndex]);
+
+                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        break;
                 default:
                         goto error;
                 }
@@ -584,35 +657,27 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         if (temp & XDEV_U3) {
                                 if ((temp & PORT_PE) == 0)
                                         goto error;
-                                if (DEV_SUPERSPEED(temp)) {
-                                        temp = xhci_port_state_to_neutral(temp);
-                                        temp &= ~PORT_PLS_MASK;
-                                        temp |= PORT_LINK_STROBE | XDEV_U0;
-                                        xhci_writel(xhci, temp,
-                                                        port_array[wIndex]);
-                                        xhci_readl(xhci, port_array[wIndex]);
-                                } else {
-                                        temp = xhci_port_state_to_neutral(temp);
-                                        temp &= ~PORT_PLS_MASK;
-                                        temp |= PORT_LINK_STROBE | XDEV_RESUME;
-                                        xhci_writel(xhci, temp,
-                                                        port_array[wIndex]);
 
-                                        spin_unlock_irqrestore(&xhci->lock,
-                                                               flags);
-                                        msleep(20);
-                                        spin_lock_irqsave(&xhci->lock, flags);
+                                temp = xhci_port_state_to_neutral(temp);
+                                temp &= ~PORT_PLS_MASK;
+                                temp |= PORT_LINK_STROBE | XDEV_RESUME;
+                                xhci_writel(xhci, temp,
+                                                port_array[wIndex]);
 
-                                        temp = xhci_readl(xhci,
-                                                        port_array[wIndex]);
-                                        temp = xhci_port_state_to_neutral(temp);
-                                        temp &= ~PORT_PLS_MASK;
-                                        temp |= PORT_LINK_STROBE | XDEV_U0;
-                                        xhci_writel(xhci, temp,
-                                                        port_array[wIndex]);
-                                }
-                                bus_state->port_c_suspend |= 1 << wIndex;
+                                spin_unlock_irqrestore(&xhci->lock,
+                                                       flags);
+                                msleep(20);
+                                spin_lock_irqsave(&xhci->lock, flags);
+
+                                temp = xhci_readl(xhci,
+                                                port_array[wIndex]);
+                                temp = xhci_port_state_to_neutral(temp);
+                                temp &= ~PORT_PLS_MASK;
+                                temp |= PORT_LINK_STROBE | XDEV_U0;
+                                xhci_writel(xhci, temp,
+                                                port_array[wIndex]);
                         }
+                        bus_state->port_c_suspend |= 1 << wIndex;
 
                         slot_id = xhci_find_slot_id_by_port(hcd, xhci,
                                         wIndex + 1);
@@ -625,9 +690,11 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 case USB_PORT_FEAT_C_SUSPEND:
                         bus_state->port_c_suspend &= ~(1 << wIndex);
                 case USB_PORT_FEAT_C_RESET:
+                case USB_PORT_FEAT_C_BH_PORT_RESET:
                 case USB_PORT_FEAT_C_CONNECTION:
                 case USB_PORT_FEAT_C_OVER_CURRENT:
                 case USB_PORT_FEAT_C_ENABLE:
+                case USB_PORT_FEAT_C_PORT_LINK_STATE:
                         xhci_clear_port_change_bit(xhci, wValue, wIndex,
                                         port_array[wIndex], temp);
                         break;
@@ -664,7 +731,7 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
         int i, retval;
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         int ports;
-        u32 __iomem **port_array;
+        __le32 __iomem **port_array;
         struct xhci_bus_state *bus_state;
 
         if (hcd->speed == HCD_USB3) {
@@ -681,7 +748,7 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
         memset(buf, 0, retval);
         status = 0;
 
-        mask = PORT_CSC | PORT_PEC | PORT_OCC;
+        mask = PORT_CSC | PORT_PEC | PORT_OCC | PORT_PLC;
 
         spin_lock_irqsave(&xhci->lock, flags);
         /* For each port, did anything change?  If so, set that bit in buf. */
@@ -709,7 +776,7 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         int max_ports, port_index;
-        u32 __iomem **port_array;
+        __le32 __iomem **port_array;
         struct xhci_bus_state *bus_state;
         unsigned long flags;
 
@@ -779,7 +846,7 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
 
                 if (hcd->speed != HCD_USB3) {
                         /* enable remote wake up for USB 2.0 */
-                        u32 __iomem *addr;
+                        __le32 __iomem *addr;
                         u32 tmp;
 
                         /* Add one to the port status register address to get
@@ -801,7 +868,7 @@ int xhci_bus_resume(struct usb_hcd *hcd)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         int max_ports, port_index;
-        u32 __iomem **port_array;
+        __le32 __iomem **port_array;
         struct xhci_bus_state *bus_state;
         u32 temp;
         unsigned long flags;
@@ -890,7 +957,7 @@ int xhci_bus_resume(struct usb_hcd *hcd)
 
                 if (hcd->speed != HCD_USB3) {
                         /* disable remote wake up for USB 2.0 */
-                        u32 __iomem *addr;
+                        __le32 __iomem *addr;
                         u32 tmp;
 
                         /* Add one to the port status register address to get
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 627f3438028c..a4fc4d929385 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -89,16 +89,17 @@ static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
                 return;
         prev->next = next;
         if (link_trbs) {
-                prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr = next->dma;
+                prev->trbs[TRBS_PER_SEGMENT-1].link.
+                        segment_ptr = cpu_to_le64(next->dma);
 
                 /* Set the last TRB in the segment to have a TRB type ID of Link TRB */
-                val = prev->trbs[TRBS_PER_SEGMENT-1].link.control;
+                val = le32_to_cpu(prev->trbs[TRBS_PER_SEGMENT-1].link.control);
                 val &= ~TRB_TYPE_BITMASK;
                 val |= TRB_TYPE(TRB_LINK);
                 /* Always set the chain bit with 0.95 hardware */
                 if (xhci_link_trb_quirk(xhci))
                         val |= TRB_CHAIN;
-                prev->trbs[TRBS_PER_SEGMENT-1].link.control = val;
+                prev->trbs[TRBS_PER_SEGMENT-1].link.control = cpu_to_le32(val);
         }
         xhci_dbg(xhci, "Linking segment 0x%llx to segment 0x%llx (DMA)\n",
                         (unsigned long long)prev->dma,
@@ -186,7 +187,8 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
 
         if (link_trbs) {
                 /* See section 4.9.2.1 and 6.4.4.1 */
-                prev->trbs[TRBS_PER_SEGMENT-1].link.control |= (LINK_TOGGLE);
+                prev->trbs[TRBS_PER_SEGMENT-1].link.
+                        control |= cpu_to_le32(LINK_TOGGLE);
                 xhci_dbg(xhci, "Wrote link toggle flag to"
                                 " segment %p (virtual), 0x%llx (DMA)\n",
                                 prev, (unsigned long long)prev->dma);
@@ -548,7 +550,8 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci,
                 addr = cur_ring->first_seg->dma |
                         SCT_FOR_CTX(SCT_PRI_TR) |
                         cur_ring->cycle_state;
-                stream_info->stream_ctx_array[cur_stream].stream_ring = addr;
+                stream_info->stream_ctx_array[cur_stream].
+                        stream_ring = cpu_to_le64(addr);
                 xhci_dbg(xhci, "Setting stream %d ring ptr to 0x%08llx\n",
                                 cur_stream, (unsigned long long) addr);
 
@@ -614,10 +617,10 @@ void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
         max_primary_streams = fls(stream_info->num_stream_ctxs) - 2;
         xhci_dbg(xhci, "Setting number of stream ctx array entries to %u\n",
                         1 << (max_primary_streams + 1));
-        ep_ctx->ep_info &= ~EP_MAXPSTREAMS_MASK;
-        ep_ctx->ep_info |= EP_MAXPSTREAMS(max_primary_streams);
-        ep_ctx->ep_info |= EP_HAS_LSA;
-        ep_ctx->deq  = stream_info->ctx_array_dma;
+        ep_ctx->ep_info &= cpu_to_le32(~EP_MAXPSTREAMS_MASK);
+        ep_ctx->ep_info |= cpu_to_le32(EP_MAXPSTREAMS(max_primary_streams)
+                                       | EP_HAS_LSA);
+        ep_ctx->deq  = cpu_to_le64(stream_info->ctx_array_dma);
 }
 
 /*
@@ -630,10 +633,9 @@ void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci,
                 struct xhci_virt_ep *ep)
 {
         dma_addr_t addr;
-        ep_ctx->ep_info &= ~EP_MAXPSTREAMS_MASK;
-        ep_ctx->ep_info &= ~EP_HAS_LSA;
+        ep_ctx->ep_info &= cpu_to_le32(~(EP_MAXPSTREAMS_MASK | EP_HAS_LSA));
         addr = xhci_trb_virt_to_dma(ep->ring->deq_seg, ep->ring->dequeue);
-        ep_ctx->deq  = addr | ep->ring->cycle_state;
+        ep_ctx->deq  = cpu_to_le64(addr | ep->ring->cycle_state);
 }
 
 /* Frees all stream contexts associated with the endpoint,
@@ -781,11 +783,11 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
         dev->udev = udev;
 
         /* Point to output device context in dcbaa. */
-        xhci->dcbaa->dev_context_ptrs[slot_id] = dev->out_ctx->dma;
+        xhci->dcbaa->dev_context_ptrs[slot_id] = cpu_to_le64(dev->out_ctx->dma);
         xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n",
-                        slot_id,
-                        &xhci->dcbaa->dev_context_ptrs[slot_id],
-                        (unsigned long long) xhci->dcbaa->dev_context_ptrs[slot_id]);
+                 slot_id,
+                 &xhci->dcbaa->dev_context_ptrs[slot_id],
+                 (unsigned long long) le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id]));
 
         return 1;
 fail:
@@ -810,8 +812,9 @@ void xhci_copy_ep0_dequeue_into_input_ctx(struct xhci_hcd *xhci,
          * configured device has reset, so all control transfers should have
          * been completed or cancelled before the reset.
          */
-        ep0_ctx->deq = xhci_trb_virt_to_dma(ep_ring->enq_seg, ep_ring->enqueue);
-        ep0_ctx->deq |= ep_ring->cycle_state;
+        ep0_ctx->deq = cpu_to_le64(xhci_trb_virt_to_dma(ep_ring->enq_seg,
+                                                        ep_ring->enqueue)
+                                   | ep_ring->cycle_state);
 }
 
 /*
@@ -885,24 +888,22 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         slot_ctx = xhci_get_slot_ctx(xhci, dev->in_ctx);
 
         /* 2) New slot context and endpoint 0 context are valid*/
-        ctrl_ctx->add_flags = SLOT_FLAG | EP0_FLAG;
+        ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG);
 
         /* 3) Only the control endpoint is valid - one endpoint context */
-        slot_ctx->dev_info |= LAST_CTX(1);
-
-        slot_ctx->dev_info |= (u32) udev->route;
+        slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | (u32) udev->route);
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-                slot_ctx->dev_info |= (u32) SLOT_SPEED_SS;
+                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_SS);
                 break;
         case USB_SPEED_HIGH:
-                slot_ctx->dev_info |= (u32) SLOT_SPEED_HS;
+                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_HS);
                 break;
         case USB_SPEED_FULL:
-                slot_ctx->dev_info |= (u32) SLOT_SPEED_FS;
+                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_FS);
                 break;
         case USB_SPEED_LOW:
-                slot_ctx->dev_info |= (u32) SLOT_SPEED_LS;
+                slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_LS);
                 break;
         case USB_SPEED_WIRELESS:
                 xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
@@ -916,7 +917,7 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         port_num = xhci_find_real_port_number(xhci, udev);
         if (!port_num)
                 return -EINVAL;
-        slot_ctx->dev_info2 |= (u32) ROOT_HUB_PORT(port_num);
+        slot_ctx->dev_info2 |= cpu_to_le32((u32) ROOT_HUB_PORT(port_num));
         /* Set the port number in the virtual_device to the faked port number */
         for (top_dev = udev; top_dev->parent && top_dev->parent->parent;
                         top_dev = top_dev->parent)
@@ -927,31 +928,31 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
 
         /* Is this a LS/FS device under an external HS hub? */
         if (udev->tt && udev->tt->hub->parent) {
-                slot_ctx->tt_info = udev->tt->hub->slot_id;
-                slot_ctx->tt_info |= udev->ttport << 8;
+                slot_ctx->tt_info = cpu_to_le32(udev->tt->hub->slot_id |
+                                                (udev->ttport << 8));
                 if (udev->tt->multi)
-                        slot_ctx->dev_info |= DEV_MTT;
+                        slot_ctx->dev_info |= cpu_to_le32(DEV_MTT);
         }
         xhci_dbg(xhci, "udev->tt = %p\n", udev->tt);
         xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport);
 
         /* Step 4 - ring already allocated */
         /* Step 5 */
-        ep0_ctx->ep_info2 = EP_TYPE(CTRL_EP);
+        ep0_ctx->ep_info2 = cpu_to_le32(EP_TYPE(CTRL_EP));
         /*
          * XXX: Not sure about wireless USB devices.
          */
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-                ep0_ctx->ep_info2 |= MAX_PACKET(512);
+                ep0_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(512));
                 break;
         case USB_SPEED_HIGH:
         /* USB core guesses at a 64-byte max packet first for FS devices */
         case USB_SPEED_FULL:
-                ep0_ctx->ep_info2 |= MAX_PACKET(64);
+                ep0_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(64));
                 break;
         case USB_SPEED_LOW:
-                ep0_ctx->ep_info2 |= MAX_PACKET(8);
+                ep0_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(8));
                 break;
         case USB_SPEED_WIRELESS:
                 xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
@@ -962,12 +963,10 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
                 BUG();
         }
         /* EP 0 can handle "burst" sizes of 1, so Max Burst Size field is 0 */
-        ep0_ctx->ep_info2 |= MAX_BURST(0);
-        ep0_ctx->ep_info2 |= ERROR_COUNT(3);
+        ep0_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(0) | ERROR_COUNT(3));
 
-        ep0_ctx->deq =
-                dev->eps[0].ring->first_seg->dma;
-        ep0_ctx->deq |= dev->eps[0].ring->cycle_state;
+        ep0_ctx->deq = cpu_to_le64(dev->eps[0].ring->first_seg->dma |
+                                   dev->eps[0].ring->cycle_state);
 
         /* Steps 7 and 8 were done in xhci_alloc_virt_device() */
 
@@ -1131,10 +1130,10 @@ static u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
                 return 0;
 
         if (udev->speed == USB_SPEED_SUPER)
-                return ep->ss_ep_comp.wBytesPerInterval;
+                return le16_to_cpu(ep->ss_ep_comp.wBytesPerInterval);
 
-        max_packet = GET_MAX_PACKET(ep->desc.wMaxPacketSize);
-        max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11;
+        max_packet = GET_MAX_PACKET(le16_to_cpu(ep->desc.wMaxPacketSize));
+        max_burst = (le16_to_cpu(ep->desc.wMaxPacketSize) & 0x1800) >> 11;
         /* A 0 in max burst means 1 transfer per ESIT */
         return max_packet * (max_burst + 1);
 }
@@ -1183,10 +1182,10 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
         }
         virt_dev->eps[ep_index].skip = false;
         ep_ring = virt_dev->eps[ep_index].new_ring;
-        ep_ctx->deq = ep_ring->first_seg->dma | ep_ring->cycle_state;
+        ep_ctx->deq = cpu_to_le64(ep_ring->first_seg->dma | ep_ring->cycle_state);
 
-        ep_ctx->ep_info = xhci_get_endpoint_interval(udev, ep);
-        ep_ctx->ep_info |= EP_MULT(xhci_get_endpoint_mult(udev, ep));
+        ep_ctx->ep_info = cpu_to_le32(xhci_get_endpoint_interval(udev, ep)
+                                      | EP_MULT(xhci_get_endpoint_mult(udev, ep)));
 
         /* FIXME dig Mult and streams info out of ep companion desc */
 
@@ -1194,22 +1193,22 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
          * error count = 0 means infinite retries.
          */
         if (!usb_endpoint_xfer_isoc(&ep->desc))
-                ep_ctx->ep_info2 = ERROR_COUNT(3);
+                ep_ctx->ep_info2 = cpu_to_le32(ERROR_COUNT(3));
         else
-                ep_ctx->ep_info2 = ERROR_COUNT(1);
+                ep_ctx->ep_info2 = cpu_to_le32(ERROR_COUNT(1));
 
-        ep_ctx->ep_info2 |= xhci_get_endpoint_type(udev, ep);
+        ep_ctx->ep_info2 |= cpu_to_le32(xhci_get_endpoint_type(udev, ep));
 
         /* Set the max packet size and max burst */
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-                max_packet = ep->desc.wMaxPacketSize;
-                ep_ctx->ep_info2 |= MAX_PACKET(max_packet);
+                max_packet = le16_to_cpu(ep->desc.wMaxPacketSize);
+                ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet));
                 /* dig out max burst from ep companion desc */
                 max_packet = ep->ss_ep_comp.bMaxBurst;
                 if (!max_packet)
                         xhci_warn(xhci, "WARN no SS endpoint bMaxBurst\n");
-                ep_ctx->ep_info2 |= MAX_BURST(max_packet);
+                ep_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(max_packet));
                 break;
         case USB_SPEED_HIGH:
                 /* bits 11:12 specify the number of additional transaction
@@ -1217,20 +1216,21 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
                  */
                 if (usb_endpoint_xfer_isoc(&ep->desc) ||
                                 usb_endpoint_xfer_int(&ep->desc)) {
-                        max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11;
-                        ep_ctx->ep_info2 |= MAX_BURST(max_burst);
+                        max_burst = (le16_to_cpu(ep->desc.wMaxPacketSize)
+                                     & 0x1800) >> 11;
+                        ep_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(max_burst));
                 }
                 /* Fall through */
         case USB_SPEED_FULL:
         case USB_SPEED_LOW:
-                max_packet = GET_MAX_PACKET(ep->desc.wMaxPacketSize);
-                ep_ctx->ep_info2 |= MAX_PACKET(max_packet);
+                max_packet = GET_MAX_PACKET(le16_to_cpu(ep->desc.wMaxPacketSize));
+                ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet));
                 break;
         default:
                 BUG();
         }
         max_esit_payload = xhci_get_max_esit_payload(xhci, udev, ep);
-        ep_ctx->tx_info = MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload);
+        ep_ctx->tx_info = cpu_to_le32(MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload));
 
         /*
          * XXX no idea how to calculate the average TRB buffer length for bulk
@@ -1247,7 +1247,7 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
          * use Event Data TRBs, and we don't chain in a link TRB on short
          * transfers, we're basically dividing by 1.
          */
-        ep_ctx->tx_info |= AVG_TRB_LENGTH_FOR_EP(max_esit_payload);
+        ep_ctx->tx_info |= cpu_to_le32(AVG_TRB_LENGTH_FOR_EP(max_esit_payload));
 
         /* FIXME Debug endpoint context */
         return 0;
@@ -1347,7 +1347,7 @@ static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
         if (!xhci->scratchpad->sp_dma_buffers)
                 goto fail_sp4;
 
-        xhci->dcbaa->dev_context_ptrs[0] = xhci->scratchpad->sp_dma;
+        xhci->dcbaa->dev_context_ptrs[0] = cpu_to_le64(xhci->scratchpad->sp_dma);
         for (i = 0; i < num_sp; i++) {
                 dma_addr_t dma;
                 void *buf = pci_alloc_consistent(to_pci_dev(dev),
@@ -1724,7 +1724,7 @@ static void xhci_set_hc_event_deq(struct xhci_hcd *xhci)
 }
 
 static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports,
-                u32 __iomem *addr, u8 major_revision)
+                __le32 __iomem *addr, u8 major_revision)
 {
         u32 temp, port_offset, port_count;
         int i;
@@ -1789,7 +1789,7 @@ static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports,
  */
 static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags)
 {
-        u32 __iomem *addr;
+        __le32 __iomem *addr;
         u32 offset;
         unsigned int num_ports;
         int i, port_index;
@@ -2042,8 +2042,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         /* set ring base address and size for each segment table entry */
         for (val = 0, seg = xhci->event_ring->first_seg; val < ERST_NUM_SEGS; val++) {
                 struct xhci_erst_entry *entry = &xhci->erst.entries[val];
-                entry->seg_addr = seg->dma;
-                entry->seg_size = TRBS_PER_SEGMENT;
+                entry->seg_addr = cpu_to_le64(seg->dma);
+                entry->seg_size = cpu_to_le32(TRBS_PER_SEGMENT);
                 entry->rsvd = 0;
                 seg = seg->next;
         }
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index a10494c2f3c7..cbc4d491e626 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/pci.h>
+#include <linux/slab.h>
 
 #include "xhci.h"
 
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 7437386a9a50..396f8d2a2e8d 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -100,7 +100,7 @@ static bool last_trb_on_last_seg(struct xhci_hcd *xhci, struct xhci_ring *ring,
                 return (trb == &seg->trbs[TRBS_PER_SEGMENT]) &&
                         (seg->next == xhci->event_ring->first_seg);
         else
-                return trb->link.control & LINK_TOGGLE;
+                return le32_to_cpu(trb->link.control) & LINK_TOGGLE;
 }
 
 /* Is this TRB a link TRB or was the last TRB the last TRB in this event ring
@@ -113,13 +113,15 @@ static int last_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
         if (ring == xhci->event_ring)
                 return trb == &seg->trbs[TRBS_PER_SEGMENT];
         else
-                return (trb->link.control & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK);
+                return (le32_to_cpu(trb->link.control) & TRB_TYPE_BITMASK)
+                        == TRB_TYPE(TRB_LINK);
 }
 
 static int enqueue_is_link_trb(struct xhci_ring *ring)
 {
         struct xhci_link_trb *link = &ring->enqueue->link;
-        return ((link->control & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK));
+        return ((le32_to_cpu(link->control) & TRB_TYPE_BITMASK) ==
+                TRB_TYPE(TRB_LINK));
 }
 
 /* Updates trb to point to the next TRB in the ring, and updates seg if the next
@@ -197,7 +199,7 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
         union xhci_trb *next;
         unsigned long long addr;
 
-        chain = ring->enqueue->generic.field[3] & TRB_CHAIN;
+        chain = le32_to_cpu(ring->enqueue->generic.field[3]) & TRB_CHAIN;
         next = ++(ring->enqueue);
 
         ring->enq_updates++;
@@ -223,12 +225,14 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
                                  * (which may mean the chain bit is cleared).
                                  */
                                 if (!xhci_link_trb_quirk(xhci)) {
-                                        next->link.control &= ~TRB_CHAIN;
-                                        next->link.control |= chain;
+                                        next->link.control &=
+                                                cpu_to_le32(~TRB_CHAIN);
+                                        next->link.control |=
+                                                cpu_to_le32(chain);
                                 }
                                 /* Give this link TRB to the hardware */
                                 wmb();
-                                next->link.control ^= TRB_CYCLE;
+                                next->link.control ^= cpu_to_le32(TRB_CYCLE);
                         }
                         /* Toggle the cycle bit after the last ring segment. */
                         if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
@@ -319,7 +323,7 @@ void xhci_ring_ep_doorbell(struct xhci_hcd *xhci,
                 unsigned int ep_index,
                 unsigned int stream_id)
 {
-        __u32 __iomem *db_addr = &xhci->dba->doorbell[slot_id];
+        __le32 __iomem *db_addr = &xhci->dba->doorbell[slot_id];
         struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
         unsigned int ep_state = ep->ep_state;
 
@@ -380,7 +384,7 @@ static struct xhci_segment *find_trb_seg(
         while (cur_seg->trbs > trb ||
                         &cur_seg->trbs[TRBS_PER_SEGMENT - 1] < trb) {
                 generic_trb = &cur_seg->trbs[TRBS_PER_SEGMENT - 1].generic;
-                if (generic_trb->field[3] & LINK_TOGGLE)
+                if (le32_to_cpu(generic_trb->field[3]) & LINK_TOGGLE)
                         *cycle_state ^= 0x1;
                 cur_seg = cur_seg->next;
                 if (cur_seg == start_seg)
@@ -447,6 +451,10 @@ static struct xhci_ring *xhci_urb_to_transfer_ring(struct xhci_hcd *xhci,
  *    any link TRBs with the toggle cycle bit set.
  *  - Finally we move the dequeue state one TRB further, toggling the cycle bit
  *    if we've moved it past a link TRB with the toggle cycle bit set.
+ *
+ * Some of the uses of xhci_generic_trb are grotty, but if they're done
+ * with correct __le32 accesses they should work fine.  Only users of this are
+ * in here.
  */
 void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
@@ -480,7 +488,7 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
         /* Dig out the cycle state saved by the xHC during the stop ep cmd */
         xhci_dbg(xhci, "Finding endpoint context\n");
         ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
-        state->new_cycle_state = 0x1 & ep_ctx->deq;
+        state->new_cycle_state = 0x1 & le64_to_cpu(ep_ctx->deq);
 
         state->new_deq_ptr = cur_td->last_trb;
         xhci_dbg(xhci, "Finding segment containing last TRB in TD.\n");
@@ -493,8 +501,8 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
         }
 
         trb = &state->new_deq_ptr->generic;
-        if ((trb->field[3] & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK) &&
-                                (trb->field[3] & LINK_TOGGLE))
+        if ((le32_to_cpu(trb->field[3]) & TRB_TYPE_BITMASK) ==
+            TRB_TYPE(TRB_LINK) && (le32_to_cpu(trb->field[3]) & LINK_TOGGLE))
                 state->new_cycle_state ^= 0x1;
         next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr);
 
@@ -529,12 +537,12 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
         for (cur_seg = cur_td->start_seg, cur_trb = cur_td->first_trb;
                         true;
                         next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                if ((cur_trb->generic.field[3] & TRB_TYPE_BITMASK) ==
-                                TRB_TYPE(TRB_LINK)) {
+                if ((le32_to_cpu(cur_trb->generic.field[3]) & TRB_TYPE_BITMASK)
+                    == TRB_TYPE(TRB_LINK)) {
                         /* Unchain any chained Link TRBs, but
                          * leave the pointers intact.
                          */
-                        cur_trb->generic.field[3] &= ~TRB_CHAIN;
+                        cur_trb->generic.field[3] &= cpu_to_le32(~TRB_CHAIN);
                         xhci_dbg(xhci, "Cancel (unchain) link TRB\n");
                         xhci_dbg(xhci, "Address = %p (0x%llx dma); "
                                         "in seg %p (0x%llx dma)\n",
@@ -547,8 +555,9 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                         cur_trb->generic.field[1] = 0;
                         cur_trb->generic.field[2] = 0;
                         /* Preserve only the cycle bit of this TRB */
-                        cur_trb->generic.field[3] &= TRB_CYCLE;
-                        cur_trb->generic.field[3] |= TRB_TYPE(TRB_TR_NOOP);
+                        cur_trb->generic.field[3] &= cpu_to_le32(TRB_CYCLE);
+                        cur_trb->generic.field[3] |= cpu_to_le32(
+                                TRB_TYPE(TRB_TR_NOOP));
                         xhci_dbg(xhci, "Cancel TRB %p (0x%llx dma) "
                                         "in seg %p (0x%llx dma)\n",
                                         cur_trb,
@@ -662,9 +671,9 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
         struct xhci_dequeue_state deq_state;
 
         if (unlikely(TRB_TO_SUSPEND_PORT(
-                        xhci->cmd_ring->dequeue->generic.field[3]))) {
+                             le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3])))) {
                 slot_id = TRB_TO_SLOT_ID(
-                        xhci->cmd_ring->dequeue->generic.field[3]);
+                        le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3]));
                 virt_dev = xhci->devs[slot_id];
                 if (virt_dev)
                         handle_cmd_in_cmd_wait_list(xhci, virt_dev,
@@ -677,8 +686,8 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
         }
 
         memset(&deq_state, 0, sizeof(deq_state));
-        slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
-        ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(trb->generic.field[3]));
+        ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
         ep = &xhci->devs[slot_id]->eps[ep_index];
 
         if (list_empty(&ep->cancelled_td_list)) {
@@ -910,9 +919,9 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
         struct xhci_ep_ctx *ep_ctx;
         struct xhci_slot_ctx *slot_ctx;
 
-        slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
-        ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
-        stream_id = TRB_TO_STREAM_ID(trb->generic.field[2]);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(trb->generic.field[3]));
+        ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
+        stream_id = TRB_TO_STREAM_ID(le32_to_cpu(trb->generic.field[2]));
         dev = xhci->devs[slot_id];
 
         ep_ring = xhci_stream_id_to_ring(dev, ep_index, stream_id);
@@ -928,11 +937,11 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
         ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
         slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx);
 
-        if (GET_COMP_CODE(event->status) != COMP_SUCCESS) {
+        if (GET_COMP_CODE(le32_to_cpu(event->status)) != COMP_SUCCESS) {
                 unsigned int ep_state;
                 unsigned int slot_state;
 
-                switch (GET_COMP_CODE(event->status)) {
+                switch (GET_COMP_CODE(le32_to_cpu(event->status))) {
                 case COMP_TRB_ERR:
                         xhci_warn(xhci, "WARN Set TR Deq Ptr cmd invalid because "
                                         "of stream ID configuration\n");
@@ -940,9 +949,9 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
                 case COMP_CTX_STATE:
                         xhci_warn(xhci, "WARN Set TR Deq Ptr cmd failed due "
                                         "to incorrect slot or ep state.\n");
-                        ep_state = ep_ctx->ep_info;
+                        ep_state = le32_to_cpu(ep_ctx->ep_info);
                         ep_state &= EP_STATE_MASK;
-                        slot_state = slot_ctx->dev_state;
+                        slot_state = le32_to_cpu(slot_ctx->dev_state);
                         slot_state = GET_SLOT_STATE(slot_state);
                         xhci_dbg(xhci, "Slot state = %u, EP state = %u\n",
                                         slot_state, ep_state);
@@ -954,7 +963,7 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
                 default:
                         xhci_warn(xhci, "WARN Set TR Deq Ptr cmd with unknown "
                                         "completion code of %u.\n",
-                                        GET_COMP_CODE(event->status));
+                                  GET_COMP_CODE(le32_to_cpu(event->status)));
                         break;
                 }
                 /* OK what do we do now?  The endpoint state is hosed, and we
@@ -965,10 +974,10 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
                  */
         } else {
                 xhci_dbg(xhci, "Successful Set TR Deq Ptr cmd, deq = @%08llx\n",
-                                ep_ctx->deq);
+                         le64_to_cpu(ep_ctx->deq));
                 if (xhci_trb_virt_to_dma(dev->eps[ep_index].queued_deq_seg,
-                                        dev->eps[ep_index].queued_deq_ptr) ==
-                                (ep_ctx->deq & ~(EP_CTX_CYCLE_MASK))) {
+                                         dev->eps[ep_index].queued_deq_ptr) ==
+                    (le64_to_cpu(ep_ctx->deq) & ~(EP_CTX_CYCLE_MASK))) {
                         /* Update the ring's dequeue segment and dequeue pointer
                          * to reflect the new position.
                          */
@@ -997,13 +1006,13 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci,
         int slot_id;
         unsigned int ep_index;
 
-        slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
-        ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(trb->generic.field[3]));
+        ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
         /* This command will only fail if the endpoint wasn't halted,
          * but we don't care.
          */
         xhci_dbg(xhci, "Ignoring reset ep completion code of %u\n",
-                        (unsigned int) GET_COMP_CODE(event->status));
+                 (unsigned int) GET_COMP_CODE(le32_to_cpu(event->status)));
 
         /* HW with the reset endpoint quirk needs to have a configure endpoint
          * command complete before the endpoint can be used.  Queue that here
@@ -1040,8 +1049,7 @@ static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
         if (xhci->cmd_ring->dequeue != command->command_trb)
                 return 0;
 
-        command->status =
-                GET_COMP_CODE(event->status);
+        command->status = GET_COMP_CODE(le32_to_cpu(event->status));
         list_del(&command->cmd_list);
         if (command->completion)
                 complete(command->completion);
@@ -1053,7 +1061,7 @@ static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
 static void handle_cmd_completion(struct xhci_hcd *xhci,
                 struct xhci_event_cmd *event)
 {
-        int slot_id = TRB_TO_SLOT_ID(event->flags);
+        int slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         u64 cmd_dma;
         dma_addr_t cmd_dequeue_dma;
         struct xhci_input_control_ctx *ctrl_ctx;
@@ -1062,7 +1070,7 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
         struct xhci_ring *ep_ring;
         unsigned int ep_state;
 
-        cmd_dma = event->cmd_trb;
+        cmd_dma = le64_to_cpu(event->cmd_trb);
         cmd_dequeue_dma = xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
                         xhci->cmd_ring->dequeue);
         /* Is the command ring deq ptr out of sync with the deq seg ptr? */
@@ -1075,9 +1083,10 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 xhci->error_bitmask |= 1 << 5;
                 return;
         }
-        switch (xhci->cmd_ring->dequeue->generic.field[3] & TRB_TYPE_BITMASK) {
+        switch (le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3])
+                & TRB_TYPE_BITMASK) {
         case TRB_TYPE(TRB_ENABLE_SLOT):
-                if (GET_COMP_CODE(event->status) == COMP_SUCCESS)
+                if (GET_COMP_CODE(le32_to_cpu(event->status)) == COMP_SUCCESS)
                         xhci->slot_id = slot_id;
                 else
                         xhci->slot_id = 0;
@@ -1102,7 +1111,7 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 ctrl_ctx = xhci_get_input_control_ctx(xhci,
                                 virt_dev->in_ctx);
                 /* Input ctx add_flags are the endpoint index plus one */
-                ep_index = xhci_last_valid_endpoint(ctrl_ctx->add_flags) - 1;
+                ep_index = xhci_last_valid_endpoint(le32_to_cpu(ctrl_ctx->add_flags)) - 1;
                 /* A usb_set_interface() call directly after clearing a halted
                  * condition may race on this quirky hardware.  Not worth
                  * worrying about, since this is prototype hardware.  Not sure
@@ -1111,8 +1120,8 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                  */
                 if (xhci->quirks & XHCI_RESET_EP_QUIRK &&
                                 ep_index != (unsigned int) -1 &&
-                                ctrl_ctx->add_flags - SLOT_FLAG ==
-                                        ctrl_ctx->drop_flags) {
+                    le32_to_cpu(ctrl_ctx->add_flags) - SLOT_FLAG ==
+                    le32_to_cpu(ctrl_ctx->drop_flags)) {
                         ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
                         ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;
                         if (!(ep_state & EP_HALTED))
@@ -1129,18 +1138,18 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
 bandwidth_change:
                 xhci_dbg(xhci, "Completed config ep cmd\n");
                 xhci->devs[slot_id]->cmd_status =
-                        GET_COMP_CODE(event->status);
+                        GET_COMP_CODE(le32_to_cpu(event->status));
                 complete(&xhci->devs[slot_id]->cmd_completion);
                 break;
         case TRB_TYPE(TRB_EVAL_CONTEXT):
                 virt_dev = xhci->devs[slot_id];
                 if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
                         break;
-                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(event->status);
+                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(le32_to_cpu(event->status));
                 complete(&xhci->devs[slot_id]->cmd_completion);
                 break;
         case TRB_TYPE(TRB_ADDR_DEV):
-                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(event->status);
+                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(le32_to_cpu(event->status));
                 complete(&xhci->addr_dev);
                 break;
         case TRB_TYPE(TRB_STOP_RING):
@@ -1157,7 +1166,7 @@ bandwidth_change:
         case TRB_TYPE(TRB_RESET_DEV):
                 xhci_dbg(xhci, "Completed reset device command.\n");
                 slot_id = TRB_TO_SLOT_ID(
-                                xhci->cmd_ring->dequeue->generic.field[3]);
+                        le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3]));
                 virt_dev = xhci->devs[slot_id];
                 if (virt_dev)
                         handle_cmd_in_cmd_wait_list(xhci, virt_dev, event);
@@ -1171,8 +1180,8 @@ bandwidth_change:
                         break;
                 }
                 xhci_dbg(xhci, "NEC firmware version %2x.%02x\n",
-                                NEC_FW_MAJOR(event->status),
-                                NEC_FW_MINOR(event->status));
+                         NEC_FW_MAJOR(le32_to_cpu(event->status)),
+                         NEC_FW_MINOR(le32_to_cpu(event->status)));
                 break;
         default:
                 /* Skip over unknown commands on the event ring */
@@ -1187,7 +1196,7 @@ static void handle_vendor_event(struct xhci_hcd *xhci,
 {
         u32 trb_type;
 
-        trb_type = TRB_FIELD_TO_TYPE(event->generic.field[3]);
+        trb_type = TRB_FIELD_TO_TYPE(le32_to_cpu(event->generic.field[3]));
         xhci_dbg(xhci, "Vendor specific event TRB type = %u\n", trb_type);
         if (trb_type == TRB_NEC_CMD_COMP && (xhci->quirks & XHCI_NEC_HOST))
                 handle_cmd_completion(xhci, &event->event_cmd);
@@ -1241,15 +1250,15 @@ static void handle_port_status(struct xhci_hcd *xhci,
         unsigned int faked_port_index;
         u8 major_revision;
         struct xhci_bus_state *bus_state;
-        u32 __iomem **port_array;
+        __le32 __iomem **port_array;
         bool bogus_port_status = false;
 
         /* Port status change events always have a successful completion code */
-        if (GET_COMP_CODE(event->generic.field[2]) != COMP_SUCCESS) {
+        if (GET_COMP_CODE(le32_to_cpu(event->generic.field[2])) != COMP_SUCCESS) {
                 xhci_warn(xhci, "WARN: xHC returned failed port status event\n");
                 xhci->error_bitmask |= 1 << 8;
         }
-        port_id = GET_PORT_ID(event->generic.field[0]);
+        port_id = GET_PORT_ID(le32_to_cpu(event->generic.field[0]));
         xhci_dbg(xhci, "Port Status Change Event for port %d\n", port_id);
 
         max_ports = HCS_MAX_PORTS(xhci->hcs_params1);
@@ -1456,7 +1465,7 @@ static int xhci_requires_manual_halt_cleanup(struct xhci_hcd *xhci,
                  * endpoint anyway.  Check if a babble halted the
                  * endpoint.
                  */
-                if ((ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_HALTED)
+                if ((le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) == EP_STATE_HALTED)
                         return 1;
 
         return 0;
@@ -1494,12 +1503,12 @@ static int finish_td(struct xhci_hcd *xhci, struct xhci_td *td,
         struct urb_priv *urb_priv;
         u32 trb_comp_code;
 
-        slot_id = TRB_TO_SLOT_ID(event->flags);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         xdev = xhci->devs[slot_id];
-        ep_index = TRB_TO_EP_ID(event->flags) - 1;
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
+        ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
         ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 
         if (skip)
                 goto td_cleanup;
@@ -1602,12 +1611,12 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
         struct xhci_ep_ctx *ep_ctx;
         u32 trb_comp_code;
 
-        slot_id = TRB_TO_SLOT_ID(event->flags);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         xdev = xhci->devs[slot_id];
-        ep_index = TRB_TO_EP_ID(event->flags) - 1;
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
+        ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
         ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 
         xhci_debug_trb(xhci, xhci->event_ring->dequeue);
         switch (trb_comp_code) {
@@ -1646,7 +1655,7 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
                                 event_trb != td->last_trb)
                         td->urb->actual_length =
                                 td->urb->transfer_buffer_length
-                                - TRB_LEN(event->transfer_len);
+                                - TRB_LEN(le32_to_cpu(event->transfer_len));
                 else
                         td->urb->actual_length = 0;
 
@@ -1680,7 +1689,7 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
                                 /* We didn't stop on a link TRB in the middle */
                                 td->urb->actual_length =
                                         td->urb->transfer_buffer_length -
-                                        TRB_LEN(event->transfer_len);
+                                        TRB_LEN(le32_to_cpu(event->transfer_len));
                                 xhci_dbg(xhci, "Waiting for status "
                                                 "stage event\n");
                                 return 0;
@@ -1708,8 +1717,8 @@ static int process_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td,
         u32 trb_comp_code;
         bool skip_td = false;
 
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
         urb_priv = td->urb->hcpriv;
         idx = urb_priv->td_cnt;
         frame = &td->urb->iso_frame_desc[idx];
@@ -1752,15 +1761,14 @@ static int process_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 for (cur_trb = ep_ring->dequeue,
                      cur_seg = ep_ring->deq_seg; cur_trb != event_trb;
                      next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                        if ((cur_trb->generic.field[3] &
+                        if ((le32_to_cpu(cur_trb->generic.field[3]) &
                          TRB_TYPE_BITMASK) != TRB_TYPE(TRB_TR_NOOP) &&
-                            (cur_trb->generic.field[3] &
+                            (le32_to_cpu(cur_trb->generic.field[3]) &
                          TRB_TYPE_BITMASK) != TRB_TYPE(TRB_LINK))
-                                len +=
-                                    TRB_LEN(cur_trb->generic.field[2]);
+                                len += TRB_LEN(le32_to_cpu(cur_trb->generic.field[2]));
                 }
-                len += TRB_LEN(cur_trb->generic.field[2]) -
-                        TRB_LEN(event->transfer_len);
+                len += TRB_LEN(le32_to_cpu(cur_trb->generic.field[2])) -
+                        TRB_LEN(le32_to_cpu(event->transfer_len));
 
                 if (trb_comp_code != COMP_STOP_INVAL) {
                         frame->actual_length = len;
@@ -1815,8 +1823,8 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
         struct xhci_segment *cur_seg;
         u32 trb_comp_code;
 
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 
         switch (trb_comp_code) {
         case COMP_SUCCESS:
@@ -1852,18 +1860,18 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                         "%d bytes untransferred\n",
                         td->urb->ep->desc.bEndpointAddress,
                         td->urb->transfer_buffer_length,
-                        TRB_LEN(event->transfer_len));
+                 TRB_LEN(le32_to_cpu(event->transfer_len)));
         /* Fast path - was this the last TRB in the TD for this URB? */
         if (event_trb == td->last_trb) {
-                if (TRB_LEN(event->transfer_len) != 0) {
+                if (TRB_LEN(le32_to_cpu(event->transfer_len)) != 0) {
                         td->urb->actual_length =
                                 td->urb->transfer_buffer_length -
-                                TRB_LEN(event->transfer_len);
+                                TRB_LEN(le32_to_cpu(event->transfer_len));
                         if (td->urb->transfer_buffer_length <
                                         td->urb->actual_length) {
                                 xhci_warn(xhci, "HC gave bad length "
                                                 "of %d bytes left\n",
-                                                TRB_LEN(event->transfer_len));
+                                          TRB_LEN(le32_to_cpu(event->transfer_len)));
                                 td->urb->actual_length = 0;
                                 if (td->urb->transfer_flags & URB_SHORT_NOT_OK)
                                         *status = -EREMOTEIO;
@@ -1894,20 +1902,20 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 for (cur_trb = ep_ring->dequeue, cur_seg = ep_ring->deq_seg;
                                 cur_trb != event_trb;
                                 next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {
-                        if ((cur_trb->generic.field[3] &
+                        if ((le32_to_cpu(cur_trb->generic.field[3]) &
                          TRB_TYPE_BITMASK) != TRB_TYPE(TRB_TR_NOOP) &&
-                            (cur_trb->generic.field[3] &
+                            (le32_to_cpu(cur_trb->generic.field[3]) &
                          TRB_TYPE_BITMASK) != TRB_TYPE(TRB_LINK))
                                 td->urb->actual_length +=
-                                        TRB_LEN(cur_trb->generic.field[2]);
+                                        TRB_LEN(le32_to_cpu(cur_trb->generic.field[2]));
                 }
                 /* If the ring didn't stop on a Link or No-op TRB, add
                  * in the actual bytes transferred from the Normal TRB
                  */
                 if (trb_comp_code != COMP_STOP_INVAL)
                         td->urb->actual_length +=
-                                TRB_LEN(cur_trb->generic.field[2]) -
-                                TRB_LEN(event->transfer_len);
+                                TRB_LEN(le32_to_cpu(cur_trb->generic.field[2])) -
+                                TRB_LEN(le32_to_cpu(event->transfer_len));
         }
 
         return finish_td(xhci, td, event_trb, event, ep, status, false);
@@ -1937,7 +1945,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         u32 trb_comp_code;
         int ret = 0;
 
-        slot_id = TRB_TO_SLOT_ID(event->flags);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         xdev = xhci->devs[slot_id];
         if (!xdev) {
                 xhci_err(xhci, "ERROR Transfer event pointed to bad slot\n");
@@ -1945,20 +1953,21 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         }
 
         /* Endpoint ID is 1 based, our index is zero based */
-        ep_index = TRB_TO_EP_ID(event->flags) - 1;
+        ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
         xhci_dbg(xhci, "%s - ep index = %d\n", __func__, ep_index);
         ep = &xdev->eps[ep_index];
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
         ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
         if (!ep_ring ||
-                (ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_DISABLED) {
+            (le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) ==
+            EP_STATE_DISABLED) {
                 xhci_err(xhci, "ERROR Transfer event for disabled endpoint "
                                 "or incorrect stream ring\n");
                 return -ENODEV;
         }
 
-        event_dma = event->buffer;
-        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        event_dma = le64_to_cpu(event->buffer);
+        trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
         /* Look for common error cases */
         switch (trb_comp_code) {
         /* Skip codes that require special handling depending on
@@ -2011,14 +2020,16 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 if (!list_empty(&ep_ring->td_list))
                         xhci_dbg(xhci, "Underrun Event for slot %d ep %d "
                                         "still with TDs queued?\n",
-                                TRB_TO_SLOT_ID(event->flags), ep_index);
+                                 TRB_TO_SLOT_ID(le32_to_cpu(event->flags)),
+                                 ep_index);
                 goto cleanup;
         case COMP_OVERRUN:
                 xhci_dbg(xhci, "overrun event on endpoint\n");
                 if (!list_empty(&ep_ring->td_list))
                         xhci_dbg(xhci, "Overrun Event for slot %d ep %d "
                                         "still with TDs queued?\n",
-                                TRB_TO_SLOT_ID(event->flags), ep_index);
+                                 TRB_TO_SLOT_ID(le32_to_cpu(event->flags)),
+                                 ep_index);
                 goto cleanup;
         case COMP_MISSED_INT:
                 /*
@@ -2047,9 +2058,11 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 if (list_empty(&ep_ring->td_list)) {
                         xhci_warn(xhci, "WARN Event TRB for slot %d ep %d "
                                         "with no TDs queued?\n",
-                                  TRB_TO_SLOT_ID(event->flags), ep_index);
+                                  TRB_TO_SLOT_ID(le32_to_cpu(event->flags)),
+                                  ep_index);
                         xhci_dbg(xhci, "Event TRB with TRB type ID %u\n",
-                          (unsigned int) (event->flags & TRB_TYPE_BITMASK)>>10);
+                                 (unsigned int) (le32_to_cpu(event->flags)
+                                                 & TRB_TYPE_BITMASK)>>10);
                         xhci_print_trb_offsets(xhci, (union xhci_trb *) event);
                         if (ep->skip) {
                                 ep->skip = false;
@@ -2092,7 +2105,8 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                  * corresponding TD has been cancelled. Just ignore
                  * the TD.
                  */
-                if ((event_trb->generic.field[3] & TRB_TYPE_BITMASK)
+                if ((le32_to_cpu(event_trb->generic.field[3])
+                             & TRB_TYPE_BITMASK)
                                  == TRB_TYPE(TRB_TR_NOOP)) {
                         xhci_dbg(xhci,
                                  "event_trb is a no-op TRB. Skip it\n");
@@ -2157,8 +2171,10 @@ cleanup:
 /*
  * This function handles all OS-owned events on the event ring.  It may drop
  * xhci->lock between event processing (e.g. to pass up port status changes).
+ * Returns >0 for "possibly more events to process" (caller should call again),
+ * otherwise 0 if done.  In future, <0 returns should indicate error code.
  */
-static void xhci_handle_event(struct xhci_hcd *xhci)
+static int xhci_handle_event(struct xhci_hcd *xhci)
 {
         union xhci_trb *event;
         int update_ptrs = 1;
@@ -2167,20 +2183,25 @@ static void xhci_handle_event(struct xhci_hcd *xhci)
         xhci_dbg(xhci, "In %s\n", __func__);
         if (!xhci->event_ring || !xhci->event_ring->dequeue) {
                 xhci->error_bitmask |= 1 << 1;
-                return;
+                return 0;
         }
 
         event = xhci->event_ring->dequeue;
         /* Does the HC or OS own the TRB? */
-        if ((event->event_cmd.flags & TRB_CYCLE) !=
-                        xhci->event_ring->cycle_state) {
+        if ((le32_to_cpu(event->event_cmd.flags) & TRB_CYCLE) !=
+            xhci->event_ring->cycle_state) {
                 xhci->error_bitmask |= 1 << 2;
-                return;
+                return 0;
         }
         xhci_dbg(xhci, "%s - OS owns TRB\n", __func__);
 
+        /*
+         * Barrier between reading the TRB_CYCLE (valid) flag above and any
+         * speculative reads of the event's flags/data below.
+         */
+        rmb();
         /* FIXME: Handle more event types. */
-        switch ((event->event_cmd.flags & TRB_TYPE_BITMASK)) {
+        switch ((le32_to_cpu(event->event_cmd.flags) & TRB_TYPE_BITMASK)) {
         case TRB_TYPE(TRB_COMPLETION):
                 xhci_dbg(xhci, "%s - calling handle_cmd_completion\n", __func__);
                 handle_cmd_completion(xhci, &event->event_cmd);
@@ -2202,7 +2223,8 @@ static void xhci_handle_event(struct xhci_hcd *xhci)
                         update_ptrs = 0;
                 break;
         default:
-                if ((event->event_cmd.flags & TRB_TYPE_BITMASK) >= TRB_TYPE(48))
+                if ((le32_to_cpu(event->event_cmd.flags) & TRB_TYPE_BITMASK) >=
+                    TRB_TYPE(48))
                         handle_vendor_event(xhci, event);
                 else
                         xhci->error_bitmask |= 1 << 3;
@@ -2213,15 +2235,17 @@ static void xhci_handle_event(struct xhci_hcd *xhci)
         if (xhci->xhc_state & XHCI_STATE_DYING) {
                 xhci_dbg(xhci, "xHCI host dying, returning from "
                                 "event handler.\n");
-                return;
+                return 0;
         }
 
         if (update_ptrs)
                 /* Update SW event ring dequeue pointer */
                 inc_deq(xhci, xhci->event_ring, true);
 
-        /* Are there more items on the event ring? */
-        xhci_handle_event(xhci);
+        /* Are there more items on the event ring?  Caller will call us again to
+         * check.
+         */
+        return 1;
 }
 
 /*
@@ -2252,12 +2276,12 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd)
         xhci_dbg(xhci, "op reg status = %08x\n", status);
         xhci_dbg(xhci, "Event ring dequeue ptr:\n");
         xhci_dbg(xhci, "@%llx %08x %08x %08x %08x\n",
-                        (unsigned long long)
-                        xhci_trb_virt_to_dma(xhci->event_ring->deq_seg, trb),
-                        lower_32_bits(trb->link.segment_ptr),
-                        upper_32_bits(trb->link.segment_ptr),
-                        (unsigned int) trb->link.intr_target,
-                        (unsigned int) trb->link.control);
+                 (unsigned long long)
+                 xhci_trb_virt_to_dma(xhci->event_ring->deq_seg, trb),
+                 lower_32_bits(le64_to_cpu(trb->link.segment_ptr)),
+                 upper_32_bits(le64_to_cpu(trb->link.segment_ptr)),
+                 (unsigned int) le32_to_cpu(trb->link.intr_target),
+                 (unsigned int) le32_to_cpu(trb->link.control));
 
         if (status & STS_FATAL) {
                 xhci_warn(xhci, "WARNING: Host System Error\n");
@@ -2303,7 +2327,7 @@ hw_died:
         /* FIXME this should be a delayed service routine
          * that clears the EHB.
          */
-        xhci_handle_event(xhci);
+        while (xhci_handle_event(xhci) > 0) {}
 
         temp_64 = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
         /* If necessary, update the HW's version of the event ring deq ptr. */
@@ -2358,10 +2382,10 @@ static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring,
         struct xhci_generic_trb *trb;
 
         trb = &ring->enqueue->generic;
-        trb->field[0] = field1;
-        trb->field[1] = field2;
-        trb->field[2] = field3;
-        trb->field[3] = field4;
+        trb->field[0] = cpu_to_le32(field1);
+        trb->field[1] = cpu_to_le32(field2);
+        trb->field[2] = cpu_to_le32(field3);
+        trb->field[3] = cpu_to_le32(field4);
         inc_enq(xhci, ring, consumer, more_trbs_coming);
 }
 
@@ -2414,17 +2438,16 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                 next = ring->enqueue;
 
                 while (last_trb(xhci, ring, ring->enq_seg, next)) {
-
                         /* If we're not dealing with 0.95 hardware,
                          * clear the chain bit.
                          */
                         if (!xhci_link_trb_quirk(xhci))
-                                next->link.control &= ~TRB_CHAIN;
+                                next->link.control &= cpu_to_le32(~TRB_CHAIN);
                         else
-                                next->link.control |= TRB_CHAIN;
+                                next->link.control |= cpu_to_le32(TRB_CHAIN);
 
                         wmb();
-                        next->link.control ^= (u32) TRB_CYCLE;
+                        next->link.control ^= cpu_to_le32((u32) TRB_CYCLE);
 
                         /* Toggle the cycle bit after the last ring segment. */
                         if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {
@@ -2467,8 +2490,8 @@ static int prepare_transfer(struct xhci_hcd *xhci,
         }
 
         ret = prepare_ring(xhci, ep_ring,
-                        ep_ctx->ep_info & EP_STATE_MASK,
-                        num_trbs, mem_flags);
+                           le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK,
+                           num_trbs, mem_flags);
         if (ret)
                 return ret;
 
@@ -2570,9 +2593,9 @@ static void giveback_first_trb(struct xhci_hcd *xhci, int slot_id,
          */
         wmb();
         if (start_cycle)
-                start_trb->field[3] |= start_cycle;
+                start_trb->field[3] |= cpu_to_le32(start_cycle);
         else
-                start_trb->field[3] &= ~0x1;
+                start_trb->field[3] &= cpu_to_le32(~TRB_CYCLE);
         xhci_ring_ep_doorbell(xhci, slot_id, ep_index, stream_id);
 }
 
@@ -2590,7 +2613,7 @@ int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         int xhci_interval;
         int ep_interval;
 
-        xhci_interval = EP_INTERVAL_TO_UFRAMES(ep_ctx->ep_info);
+        xhci_interval = EP_INTERVAL_TO_UFRAMES(le32_to_cpu(ep_ctx->ep_info));
         ep_interval = urb->interval;
         /* Convert to microframes */
         if (urb->dev->speed == USB_SPEED_LOW ||
@@ -2632,6 +2655,35 @@ static u32 xhci_td_remainder(unsigned int remainder)
                 return (remainder >> 10) << 17;
 }
 
+/*
+ * For xHCI 1.0 host controllers, TD size is the number of packets remaining in
+ * the TD (*not* including this TRB).
+ *
+ * Total TD packet count = total_packet_count =
+ *     roundup(TD size in bytes / wMaxPacketSize)
+ *
+ * Packets transferred up to and including this TRB = packets_transferred =
+ *     rounddown(total bytes transferred including this TRB / wMaxPacketSize)
+ *
+ * TD size = total_packet_count - packets_transferred
+ *
+ * It must fit in bits 21:17, so it can't be bigger than 31.
+ */
+
+static u32 xhci_v1_0_td_remainder(int running_total, int trb_buff_len,
+                unsigned int total_packet_count, struct urb *urb)
+{
+        int packets_transferred;
+
+        /* All the TRB queueing functions don't count the current TRB in
+         * running_total.
+         */
+        packets_transferred = (running_total + trb_buff_len) /
+                le16_to_cpu(urb->ep->desc.wMaxPacketSize);
+
+        return xhci_td_remainder(total_packet_count - packets_transferred);
+}
+
 static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 struct urb *urb, int slot_id, unsigned int ep_index)
 {
@@ -2642,6 +2694,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         struct scatterlist *sg;
         int num_sgs;
         int trb_buff_len, this_sg_len, running_total;
+        unsigned int total_packet_count;
         bool first_trb;
         u64 addr;
         bool more_trbs_coming;
@@ -2655,6 +2708,8 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
         num_trbs = count_sg_trbs_needed(xhci, urb);
         num_sgs = urb->num_sgs;
+        total_packet_count = roundup(urb->transfer_buffer_length,
+                        le16_to_cpu(urb->ep->desc.wMaxPacketSize));
 
         trb_buff_len = prepare_transfer(xhci, xhci->devs[slot_id],
                         ep_index, urb->stream_id,
@@ -2718,6 +2773,11 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         td->last_trb = ep_ring->enqueue;
                         field |= TRB_IOC;
                 }
+
+                /* Only set interrupt on short packet for IN endpoints */
+                if (usb_urb_dir_in(urb))
+                        field |= TRB_ISP;
+
                 xhci_dbg(xhci, " sg entry: dma = %#x, len = %#x (%d), "
                                 "64KB boundary at %#x, end dma = %#x\n",
                                 (unsigned int) addr, trb_buff_len, trb_buff_len,
@@ -2730,11 +2790,20 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                         (unsigned int) (addr + TRB_MAX_BUFF_SIZE) & ~(TRB_MAX_BUFF_SIZE - 1),
                                         (unsigned int) addr + trb_buff_len);
                 }
-                remainder = xhci_td_remainder(urb->transfer_buffer_length -
-                                running_total) ;
+
+                /* Set the TRB length, TD size, and interrupter fields. */
+                if (xhci->hci_version < 0x100) {
+                        remainder = xhci_td_remainder(
+                                        urb->transfer_buffer_length -
+                                        running_total);
+                } else {
+                        remainder = xhci_v1_0_td_remainder(running_total,
+                                        trb_buff_len, total_packet_count, urb);
+                }
                 length_field = TRB_LEN(trb_buff_len) |
                         remainder |
                         TRB_INTR_TARGET(0);
+
                 if (num_trbs > 1)
                         more_trbs_coming = true;
                 else
@@ -2743,12 +2812,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 lower_32_bits(addr),
                                 upper_32_bits(addr),
                                 length_field,
-                                /* We always want to know if the TRB was short,
-                                 * or we won't get an event when it completes.
-                                 * (Unless we use event data TRBs, which are a
-                                 * waste of space and HC resources.)
-                                 */
-                                field | TRB_ISP | TRB_TYPE(TRB_NORMAL));
+                                field | TRB_TYPE(TRB_NORMAL));
                 --num_trbs;
                 running_total += trb_buff_len;
 
@@ -2796,6 +2860,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         u32 field, length_field;
 
         int running_total, trb_buff_len, ret;
+        unsigned int total_packet_count;
         u64 addr;
 
         if (urb->num_sgs)
@@ -2850,6 +2915,8 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         start_cycle = ep_ring->cycle_state;
 
         running_total = 0;
+        total_packet_count = roundup(urb->transfer_buffer_length,
+                        le16_to_cpu(urb->ep->desc.wMaxPacketSize));
         /* How much data is in the first TRB? */
         addr = (u64) urb->transfer_dma;
         trb_buff_len = TRB_MAX_BUFF_SIZE -
@@ -2882,11 +2949,24 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         td->last_trb = ep_ring->enqueue;
                         field |= TRB_IOC;
                 }
-                remainder = xhci_td_remainder(urb->transfer_buffer_length -
-                                running_total);
+
+                /* Only set interrupt on short packet for IN endpoints */
+                if (usb_urb_dir_in(urb))
+                        field |= TRB_ISP;
+
+                /* Set the TRB length, TD size, and interrupter fields. */
+                if (xhci->hci_version < 0x100) {
+                        remainder = xhci_td_remainder(
+                                        urb->transfer_buffer_length -
+                                        running_total);
+                } else {
+                        remainder = xhci_v1_0_td_remainder(running_total,
+                                        trb_buff_len, total_packet_count, urb);
+                }
                 length_field = TRB_LEN(trb_buff_len) |
                         remainder |
                         TRB_INTR_TARGET(0);
+
                 if (num_trbs > 1)
                         more_trbs_coming = true;
                 else
@@ -2895,12 +2975,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 lower_32_bits(addr),
                                 upper_32_bits(addr),
                                 length_field,
-                                /* We always want to know if the TRB was short,
-                                 * or we won't get an event when it completes.
-                                 * (Unless we use event data TRBs, which are a
-                                 * waste of space and HC resources.)
-                                 */
-                                field | TRB_ISP | TRB_TYPE(TRB_NORMAL));
+                                field | TRB_TYPE(TRB_NORMAL));
                 --num_trbs;
                 running_total += trb_buff_len;
 
@@ -2979,15 +3054,19 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         if (start_cycle == 0)
                 field |= 0x1;
         queue_trb(xhci, ep_ring, false, true,
-                        /* FIXME endianness is probably going to bite my ass here. */
-                        setup->bRequestType | setup->bRequest << 8 | setup->wValue << 16,
-                        setup->wIndex | setup->wLength << 16,
-                        TRB_LEN(8) | TRB_INTR_TARGET(0),
-                        /* Immediate data in pointer */
-                        field);
+                  setup->bRequestType | setup->bRequest << 8 | le16_to_cpu(setup->wValue) << 16,
+                  le16_to_cpu(setup->wIndex) | le16_to_cpu(setup->wLength) << 16,
+                  TRB_LEN(8) | TRB_INTR_TARGET(0),
+                  /* Immediate data in pointer */
+                  field);
 
         /* If there's data, queue data TRBs */
-        field = 0;
+        /* Only set interrupt on short packet for IN endpoints */
+        if (usb_urb_dir_in(urb))
+                field = TRB_ISP | TRB_TYPE(TRB_DATA);
+        else
+                field = TRB_TYPE(TRB_DATA);
+
         length_field = TRB_LEN(urb->transfer_buffer_length) |
                 xhci_td_remainder(urb->transfer_buffer_length) |
                 TRB_INTR_TARGET(0);
@@ -2998,8 +3077,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 lower_32_bits(urb->transfer_dma),
                                 upper_32_bits(urb->transfer_dma),
                                 length_field,
-                                /* Event on short tx */
-                                field | TRB_ISP | TRB_TYPE(TRB_DATA) | ep_ring->cycle_state);
+                                field | ep_ring->cycle_state);
         }
 
         /* Save the DMA address of the last TRB in the TD */
@@ -3045,6 +3123,63 @@ static int count_isoc_trbs_needed(struct xhci_hcd *xhci,
         return num_trbs;
 }
 
+/*
+ * The transfer burst count field of the isochronous TRB defines the number of
+ * bursts that are required to move all packets in this TD.  Only SuperSpeed
+ * devices can burst up to bMaxBurst number of packets per service interval.
+ * This field is zero based, meaning a value of zero in the field means one
+ * burst.  Basically, for everything but SuperSpeed devices, this field will be
+ * zero.  Only xHCI 1.0 host controllers support this field.
+ */
+static unsigned int xhci_get_burst_count(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct urb *urb, unsigned int total_packet_count)
+{
+        unsigned int max_burst;
+
+        if (xhci->hci_version < 0x100 || udev->speed != USB_SPEED_SUPER)
+                return 0;
+
+        max_burst = urb->ep->ss_ep_comp.bMaxBurst;
+        return roundup(total_packet_count, max_burst + 1) - 1;
+}
+
+/*
+ * Returns the number of packets in the last "burst" of packets.  This field is
+ * valid for all speeds of devices.  USB 2.0 devices can only do one "burst", so
+ * the last burst packet count is equal to the total number of packets in the
+ * TD.  SuperSpeed endpoints can have up to 3 bursts.  All but the last burst
+ * must contain (bMaxBurst + 1) number of packets, but the last burst can
+ * contain 1 to (bMaxBurst + 1) packets.
+ */
+static unsigned int xhci_get_last_burst_packet_count(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct urb *urb, unsigned int total_packet_count)
+{
+        unsigned int max_burst;
+        unsigned int residue;
+
+        if (xhci->hci_version < 0x100)
+                return 0;
+
+        switch (udev->speed) {
+        case USB_SPEED_SUPER:
+                /* bMaxBurst is zero based: 0 means 1 packet per burst */
+                max_burst = urb->ep->ss_ep_comp.bMaxBurst;
+                residue = total_packet_count % (max_burst + 1);
+                /* If residue is zero, the last burst contains (max_burst + 1)
+                 * number of packets, but the TLBPC field is zero-based.
+                 */
+                if (residue == 0)
+                        return max_burst;
+                return residue - 1;
+        default:
+                if (total_packet_count == 0)
+                        return 0;
+                return total_packet_count - 1;
+        }
+}
+
 /* This is for isoc transfer */
 static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 struct urb *urb, int slot_id, unsigned int ep_index)
@@ -3085,12 +3220,22 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
         /* Queue the first TRB, even if it's zero-length */
         for (i = 0; i < num_tds; i++) {
-                first_trb = true;
+                unsigned int total_packet_count;
+                unsigned int burst_count;
+                unsigned int residue;
 
+                first_trb = true;
                 running_total = 0;
                 addr = start_addr + urb->iso_frame_desc[i].offset;
                 td_len = urb->iso_frame_desc[i].length;
                 td_remain_len = td_len;
+                /* FIXME: Ignoring zero-length packets, can those happen? */
+                total_packet_count = roundup(td_len,
+                                le16_to_cpu(urb->ep->desc.wMaxPacketSize));
+                burst_count = xhci_get_burst_count(xhci, urb->dev, urb,
+                                total_packet_count);
+                residue = xhci_get_last_burst_packet_count(xhci,
+                                urb->dev, urb, total_packet_count);
 
                 trbs_per_td = count_isoc_trbs_needed(xhci, urb, i);
 
@@ -3104,7 +3249,7 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
                 for (j = 0; j < trbs_per_td; j++) {
                         u32 remainder = 0;
-                        field = 0;
+                        field = TRB_TBC(burst_count) | TRB_TLBPC(residue);
 
                         if (first_trb) {
                                 /* Queue the isoc TRB */
@@ -3123,6 +3268,10 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 field |= ep_ring->cycle_state;
                         }
 
+                        /* Only set interrupt on short packet for IN EPs */
+                        if (usb_urb_dir_in(urb))
+                                field |= TRB_ISP;
+
                         /* Chain all the TRBs together; clear the chain bit in
                          * the last TRB to indicate it's the last TRB in the
                          * chain.
@@ -3142,20 +3291,24 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         if (trb_buff_len > td_remain_len)
                                 trb_buff_len = td_remain_len;
 
-                        remainder = xhci_td_remainder(td_len - running_total);
+                        /* Set the TRB length, TD size, & interrupter fields. */
+                        if (xhci->hci_version < 0x100) {
+                                remainder = xhci_td_remainder(
+                                                td_len - running_total);
+                        } else {
+                                remainder = xhci_v1_0_td_remainder(
+                                                running_total, trb_buff_len,
+                                                total_packet_count, urb);
+                        }
                         length_field = TRB_LEN(trb_buff_len) |
                                 remainder |
                                 TRB_INTR_TARGET(0);
+
                         queue_trb(xhci, ep_ring, false, more_trbs_coming,
                                 lower_32_bits(addr),
                                 upper_32_bits(addr),
                                 length_field,
-                                /* We always want to know if the TRB was short,
-                                 * or we won't get an event when it completes.
-                                 * (Unless we use event data TRBs, which are a
-                                 * waste of space and HC resources.)
-                                 */
-                                field | TRB_ISP);
+                                field);
                         running_total += trb_buff_len;
 
                         addr += trb_buff_len;
@@ -3211,8 +3364,8 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
         /* Check the ring to guarantee there is enough room for the whole urb.
          * Do not insert any td of the urb to the ring if the check failed.
          */
-        ret = prepare_ring(xhci, ep_ring, ep_ctx->ep_info & EP_STATE_MASK,
-                                num_trbs, mem_flags);
+        ret = prepare_ring(xhci, ep_ring, le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK,
+                           num_trbs, mem_flags);
         if (ret)
                 return ret;
 
@@ -3224,7 +3377,7 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
                         urb->dev->speed == USB_SPEED_FULL)
                 urb->start_frame >>= 3;
 
-        xhci_interval = EP_INTERVAL_TO_UFRAMES(ep_ctx->ep_info);
+        xhci_interval = EP_INTERVAL_TO_UFRAMES(le32_to_cpu(ep_ctx->ep_info));
         ep_interval = urb->interval;
         /* Convert to microframes */
         if (urb->dev->speed == USB_SPEED_LOW ||
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 81b976e45880..6864759c8d1a 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -973,8 +973,8 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
 
         out_ctx = xhci->devs[slot_id]->out_ctx;
         ep_ctx = xhci_get_ep_ctx(xhci, out_ctx, ep_index);
-        hw_max_packet_size = MAX_PACKET_DECODED(ep_ctx->ep_info2);
-        max_packet_size = urb->dev->ep0.desc.wMaxPacketSize;
+        hw_max_packet_size = MAX_PACKET_DECODED(le32_to_cpu(ep_ctx->ep_info2));
+        max_packet_size = le16_to_cpu(urb->dev->ep0.desc.wMaxPacketSize);
         if (hw_max_packet_size != max_packet_size) {
                 xhci_dbg(xhci, "Max Packet Size for ep 0 changed.\n");
                 xhci_dbg(xhci, "Max packet size in usb_device = %d\n",
@@ -988,15 +988,15 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                                 xhci->devs[slot_id]->out_ctx, ep_index);
                 in_ctx = xhci->devs[slot_id]->in_ctx;
                 ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, ep_index);
-                ep_ctx->ep_info2 &= ~MAX_PACKET_MASK;
-                ep_ctx->ep_info2 |= MAX_PACKET(max_packet_size);
+                ep_ctx->ep_info2 &= cpu_to_le32(~MAX_PACKET_MASK);
+                ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet_size));
 
                 /* Set up the input context flags for the command */
                 /* FIXME: This won't work if a non-default control endpoint
                  * changes max packet sizes.
                  */
                 ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
-                ctrl_ctx->add_flags = EP0_FLAG;
+                ctrl_ctx->add_flags = cpu_to_le32(EP0_FLAG);
                 ctrl_ctx->drop_flags = 0;
 
                 xhci_dbg(xhci, "Slot %d input context\n", slot_id);
@@ -1010,7 +1010,7 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                 /* Clean up the input context for later use by bandwidth
                  * functions.
                  */
-                ctrl_ctx->add_flags = SLOT_FLAG;
+                ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG);
         }
         return ret;
 }
@@ -1331,27 +1331,30 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
         /* If the HC already knows the endpoint is disabled,
          * or the HCD has noted it is disabled, ignore this request
          */
-        if ((ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_DISABLED ||
-                        ctrl_ctx->drop_flags & xhci_get_endpoint_flag(&ep->desc)) {
+        if ((le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) ==
+            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",
                                 __func__, ep);
                 return 0;
         }
 
-        ctrl_ctx->drop_flags |= drop_flag;
-        new_drop_flags = ctrl_ctx->drop_flags;
+        ctrl_ctx->drop_flags |= cpu_to_le32(drop_flag);
+        new_drop_flags = le32_to_cpu(ctrl_ctx->drop_flags);
 
-        ctrl_ctx->add_flags &= ~drop_flag;
-        new_add_flags = ctrl_ctx->add_flags;
+        ctrl_ctx->add_flags &= cpu_to_le32(~drop_flag);
+        new_add_flags = le32_to_cpu(ctrl_ctx->add_flags);
 
-        last_ctx = xhci_last_valid_endpoint(ctrl_ctx->add_flags);
+        last_ctx = xhci_last_valid_endpoint(le32_to_cpu(ctrl_ctx->add_flags));
         slot_ctx = xhci_get_slot_ctx(xhci, in_ctx);
         /* Update the last valid endpoint context, if we deleted the last one */
-        if ((slot_ctx->dev_info & LAST_CTX_MASK) > LAST_CTX(last_ctx)) {
-                slot_ctx->dev_info &= ~LAST_CTX_MASK;
-                slot_ctx->dev_info |= LAST_CTX(last_ctx);
+        if ((le32_to_cpu(slot_ctx->dev_info) & LAST_CTX_MASK) >
+            LAST_CTX(last_ctx)) {
+                slot_ctx->dev_info &= cpu_to_le32(~LAST_CTX_MASK);
+                slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(last_ctx));
         }
-        new_slot_info = slot_ctx->dev_info;
+        new_slot_info = le32_to_cpu(slot_ctx->dev_info);
 
         xhci_endpoint_zero(xhci, xhci->devs[udev->slot_id], ep);
 
@@ -1419,7 +1422,8 @@ 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 (ctrl_ctx->add_flags & xhci_get_endpoint_flag(&ep->desc)) {
+        if (le32_to_cpu(ctrl_ctx->add_flags) &
+            xhci_get_endpoint_flag(&ep->desc)) {
                 xhci_warn(xhci, "xHCI %s called with enabled ep %p\n",
                                 __func__, ep);
                 return 0;
@@ -1437,8 +1441,8 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
                 return -ENOMEM;
         }
 
-        ctrl_ctx->add_flags |= added_ctxs;
-        new_add_flags = ctrl_ctx->add_flags;
+        ctrl_ctx->add_flags |= cpu_to_le32(added_ctxs);
+        new_add_flags = le32_to_cpu(ctrl_ctx->add_flags);
 
         /* If xhci_endpoint_disable() was called for this endpoint, but the
          * xHC hasn't been notified yet through the check_bandwidth() call,
@@ -1446,15 +1450,16 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
          * descriptors.  We must drop and re-add this endpoint, so we leave the
          * drop flags alone.
          */
-        new_drop_flags = ctrl_ctx->drop_flags;
+        new_drop_flags = le32_to_cpu(ctrl_ctx->drop_flags);
 
         slot_ctx = xhci_get_slot_ctx(xhci, in_ctx);
         /* Update the last valid endpoint context, if we just added one past */
-        if ((slot_ctx->dev_info & LAST_CTX_MASK) < LAST_CTX(last_ctx)) {
-                slot_ctx->dev_info &= ~LAST_CTX_MASK;
-                slot_ctx->dev_info |= LAST_CTX(last_ctx);
+        if ((le32_to_cpu(slot_ctx->dev_info) & LAST_CTX_MASK) <
+            LAST_CTX(last_ctx)) {
+                slot_ctx->dev_info &= cpu_to_le32(~LAST_CTX_MASK);
+                slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(last_ctx));
         }
-        new_slot_info = slot_ctx->dev_info;
+        new_slot_info = le32_to_cpu(slot_ctx->dev_info);
 
         /* Store the usb_device pointer for later use */
         ep->hcpriv = udev;
@@ -1484,9 +1489,9 @@ static void xhci_zero_in_ctx(struct xhci_hcd *xhci, struct xhci_virt_device *vir
         ctrl_ctx->drop_flags = 0;
         ctrl_ctx->add_flags = 0;
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
-        slot_ctx->dev_info &= ~LAST_CTX_MASK;
+        slot_ctx->dev_info &= cpu_to_le32(~LAST_CTX_MASK);
         /* Endpoint 0 is always valid */
-        slot_ctx->dev_info |= LAST_CTX(1);
+        slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1));
         for (i = 1; i < 31; ++i) {
                 ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, i);
                 ep_ctx->ep_info = 0;
@@ -1497,7 +1502,7 @@ static void xhci_zero_in_ctx(struct xhci_hcd *xhci, struct xhci_virt_device *vir
 }
 
 static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
-                struct usb_device *udev, int *cmd_status)
+                struct usb_device *udev, u32 *cmd_status)
 {
         int ret;
 
@@ -1535,7 +1540,7 @@ static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
 }
 
 static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
-                struct usb_device *udev, int *cmd_status)
+                struct usb_device *udev, u32 *cmd_status)
 {
         int ret;
         struct xhci_virt_device *virt_dev = xhci->devs[udev->slot_id];
@@ -1581,7 +1586,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         unsigned long flags;
         struct xhci_container_ctx *in_ctx;
         struct completion *cmd_completion;
-        int *cmd_status;
+        u32 *cmd_status;
         struct xhci_virt_device *virt_dev;
 
         spin_lock_irqsave(&xhci->lock, flags);
@@ -1595,8 +1600,8 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 /* Enqueue pointer can be left pointing to the link TRB,
                  * we must handle that
                  */
-                if ((command->command_trb->link.control & TRB_TYPE_BITMASK)
-                                == TRB_TYPE(TRB_LINK))
+                if ((le32_to_cpu(command->command_trb->link.control)
+                     & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))
                         command->command_trb =
                                 xhci->cmd_ring->enq_seg->next->trbs;
 
@@ -1672,14 +1677,13 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
 
         /* See section 4.6.6 - A0 = 1; A1 = D0 = D1 = 0 */
         ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
-        ctrl_ctx->add_flags |= SLOT_FLAG;
-        ctrl_ctx->add_flags &= ~EP0_FLAG;
-        ctrl_ctx->drop_flags &= ~SLOT_FLAG;
-        ctrl_ctx->drop_flags &= ~EP0_FLAG;
+        ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
+        ctrl_ctx->add_flags &= cpu_to_le32(~EP0_FLAG);
+        ctrl_ctx->drop_flags &= cpu_to_le32(~(SLOT_FLAG | EP0_FLAG));
         xhci_dbg(xhci, "New Input Control Context:\n");
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
         xhci_dbg_ctx(xhci, virt_dev->in_ctx,
-                        LAST_CTX_TO_EP_NUM(slot_ctx->dev_info));
+                     LAST_CTX_TO_EP_NUM(le32_to_cpu(slot_ctx->dev_info)));
 
         ret = xhci_configure_endpoint(xhci, udev, NULL,
                         false, false);
@@ -1690,7 +1694,7 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
 
         xhci_dbg(xhci, "Output context after successful config ep cmd:\n");
         xhci_dbg_ctx(xhci, virt_dev->out_ctx,
-                        LAST_CTX_TO_EP_NUM(slot_ctx->dev_info));
+                     LAST_CTX_TO_EP_NUM(le32_to_cpu(slot_ctx->dev_info)));
 
         xhci_zero_in_ctx(xhci, virt_dev);
         /* Install new rings and free or cache any old rings */
@@ -1740,10 +1744,10 @@ static void xhci_setup_input_ctx_for_config_ep(struct xhci_hcd *xhci,
 {
         struct xhci_input_control_ctx *ctrl_ctx;
         ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
-        ctrl_ctx->add_flags = add_flags;
-        ctrl_ctx->drop_flags = drop_flags;
+        ctrl_ctx->add_flags = cpu_to_le32(add_flags);
+        ctrl_ctx->drop_flags = cpu_to_le32(drop_flags);
         xhci_slot_copy(xhci, in_ctx, out_ctx);
-        ctrl_ctx->add_flags |= SLOT_FLAG;
+        ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
 
         xhci_dbg(xhci, "Input Context:\n");
         xhci_dbg_ctx(xhci, in_ctx, xhci_last_valid_endpoint(add_flags));
@@ -1772,7 +1776,7 @@ static void xhci_setup_input_ctx_for_quirk(struct xhci_hcd *xhci,
                                 deq_state->new_deq_ptr);
                 return;
         }
-        ep_ctx->deq = addr | deq_state->new_cycle_state;
+        ep_ctx->deq = cpu_to_le64(addr | deq_state->new_cycle_state);
 
         added_ctxs = xhci_get_endpoint_flag_from_index(ep_index);
         xhci_setup_input_ctx_for_config_ep(xhci, xhci->devs[slot_id]->in_ctx,
@@ -2327,8 +2331,8 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         /* Enqueue pointer can be left pointing to the link TRB,
          * we must handle that
          */
-        if ((reset_device_cmd->command_trb->link.control & TRB_TYPE_BITMASK)
-                        == TRB_TYPE(TRB_LINK))
+        if ((le32_to_cpu(reset_device_cmd->command_trb->link.control)
+             & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))
                 reset_device_cmd->command_trb =
                         xhci->cmd_ring->enq_seg->next->trbs;
 
@@ -2542,6 +2546,17 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
 
         virt_dev = xhci->devs[udev->slot_id];
 
+        if (WARN_ON(!virt_dev)) {
+                /*
+                 * In plug/unplug torture test with an NEC controller,
+                 * a zero-dereference was observed once due to virt_dev = 0.
+                 * Print useful debug rather than crash if it is observed again!
+                 */
+                xhci_warn(xhci, "Virt dev invalid for slot_id 0x%x!\n",
+                        udev->slot_id);
+                return -EINVAL;
+        }
+
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
         /*
          * If this is the first Set Address since device plug-in or
@@ -2609,10 +2624,10 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         temp_64 = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
         xhci_dbg(xhci, "Op regs DCBAA ptr = %#016llx\n", temp_64);
         xhci_dbg(xhci, "Slot ID %d dcbaa entry @%p = %#016llx\n",
-                        udev->slot_id,
-                        &xhci->dcbaa->dev_context_ptrs[udev->slot_id],
-                        (unsigned long long)
-                                xhci->dcbaa->dev_context_ptrs[udev->slot_id]);
+                 udev->slot_id,
+                 &xhci->dcbaa->dev_context_ptrs[udev->slot_id],
+                 (unsigned long long)
+                 le64_to_cpu(xhci->dcbaa->dev_context_ptrs[udev->slot_id]));
         xhci_dbg(xhci, "Output Context DMA address = %#08llx\n",
                         (unsigned long long)virt_dev->out_ctx->dma);
         xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
@@ -2626,7 +2641,8 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx);
         /* Use kernel assigned address for devices; store xHC assigned
          * address locally. */
-        virt_dev->address = (slot_ctx->dev_state & DEV_ADDR_MASK) + 1;
+        virt_dev->address = (le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK)
+                + 1;
         /* Zero the input context control for later use */
         ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
         ctrl_ctx->add_flags = 0;
@@ -2670,16 +2686,16 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
         spin_lock_irqsave(&xhci->lock, flags);
         xhci_slot_copy(xhci, config_cmd->in_ctx, vdev->out_ctx);
         ctrl_ctx = xhci_get_input_control_ctx(xhci, config_cmd->in_ctx);
-        ctrl_ctx->add_flags |= SLOT_FLAG;
+        ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
         slot_ctx = xhci_get_slot_ctx(xhci, config_cmd->in_ctx);
-        slot_ctx->dev_info |= DEV_HUB;
+        slot_ctx->dev_info |= cpu_to_le32(DEV_HUB);
         if (tt->multi)
-                slot_ctx->dev_info |= DEV_MTT;
+                slot_ctx->dev_info |= cpu_to_le32(DEV_MTT);
         if (xhci->hci_version > 0x95) {
                 xhci_dbg(xhci, "xHCI version %x needs hub "
                                 "TT think time and number of ports\n",
                                 (unsigned int) xhci->hci_version);
-                slot_ctx->dev_info2 |= XHCI_MAX_PORTS(hdev->maxchild);
+                slot_ctx->dev_info2 |= cpu_to_le32(XHCI_MAX_PORTS(hdev->maxchild));
                 /* Set TT think time - convert from ns to FS bit times.
                  * 0 = 8 FS bit times, 1 = 16 FS bit times,
                  * 2 = 24 FS bit times, 3 = 32 FS bit times.
@@ -2687,7 +2703,7 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
                 think_time = tt->think_time;
                 if (think_time != 0)
                         think_time = (think_time / 666) - 1;
-                slot_ctx->tt_info |= TT_THINK_TIME(think_time);
+                slot_ctx->tt_info |= cpu_to_le32(TT_THINK_TIME(think_time));
         } else {
                 xhci_dbg(xhci, "xHCI version %x doesn't need hub "
                                 "TT think time or number of ports\n",
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index ba1be6b7cc6d..db661543a805 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -57,13 +57,13 @@
  * @run_regs_off:       RTSOFF - Runtime register space offset
  */
 struct xhci_cap_regs {
-        u32     hc_capbase;
-        u32     hcs_params1;
-        u32     hcs_params2;
-        u32     hcs_params3;
-        u32     hcc_params;
-        u32     db_off;
-        u32     run_regs_off;
+        __le32  hc_capbase;
+        __le32  hcs_params1;
+        __le32  hcs_params2;
+        __le32  hcs_params3;
+        __le32  hcc_params;
+        __le32  db_off;
+        __le32  run_regs_off;
         /* Reserved up to (CAPLENGTH - 0x1C) */
 };
 
@@ -155,26 +155,26 @@ struct xhci_cap_regs {
  *                      devices.
  */
 struct xhci_op_regs {
-        u32     command;
-        u32     status;
-        u32     page_size;
-        u32     reserved1;
-        u32     reserved2;
-        u32     dev_notification;
-        u64     cmd_ring;
+        __le32  command;
+        __le32  status;
+        __le32  page_size;
+        __le32  reserved1;
+        __le32  reserved2;
+        __le32  dev_notification;
+        __le64  cmd_ring;
         /* rsvd: offset 0x20-2F */
-        u32     reserved3[4];
-        u64     dcbaa_ptr;
-        u32     config_reg;
+        __le32  reserved3[4];
+        __le64  dcbaa_ptr;
+        __le32  config_reg;
         /* rsvd: offset 0x3C-3FF */
-        u32     reserved4[241];
+        __le32  reserved4[241];
         /* port 1 registers, which serve as a base address for other ports */
-        u32     port_status_base;
-        u32     port_power_base;
-        u32     port_link_base;
-        u32     reserved5;
+        __le32  port_status_base;
+        __le32  port_power_base;
+        __le32  port_link_base;
+        __le32  reserved5;
         /* registers for ports 2-255 */
-        u32     reserved6[NUM_PORT_REGS*254];
+        __le32  reserved6[NUM_PORT_REGS*254];
 };
 
 /* USBCMD - USB command - command bitmasks */
@@ -382,12 +382,12 @@ struct xhci_op_regs {
  * updates the dequeue pointer.
  */
 struct xhci_intr_reg {
-        u32     irq_pending;
-        u32     irq_control;
-        u32     erst_size;
-        u32     rsvd;
-        u64     erst_base;
-        u64     erst_dequeue;
+        __le32  irq_pending;
+        __le32  irq_control;
+        __le32  erst_size;
+        __le32  rsvd;
+        __le64  erst_base;
+        __le64  erst_dequeue;
 };
 
 /* irq_pending bitmasks */
@@ -432,8 +432,8 @@ struct xhci_intr_reg {
  * or larger accesses"
  */
 struct xhci_run_regs {
-        u32                     microframe_index;
-        u32                     rsvd[7];
+        __le32                  microframe_index;
+        __le32                  rsvd[7];
         struct xhci_intr_reg    ir_set[128];
 };
 
@@ -447,7 +447,7 @@ struct xhci_run_regs {
  * Section 5.6
  */
 struct xhci_doorbell_array {
-        u32     doorbell[256];
+        __le32  doorbell[256];
 };
 
 #define DB_VALUE(ep, stream)    ((((ep) + 1) & 0xff) | ((stream) << 16))
@@ -504,12 +504,12 @@ struct xhci_container_ctx {
  * reserved at the end of the slot context for HC internal use.
  */
 struct xhci_slot_ctx {
-        u32     dev_info;
-        u32     dev_info2;
-        u32     tt_info;
-        u32     dev_state;
+        __le32  dev_info;
+        __le32  dev_info2;
+        __le32  tt_info;
+        __le32  dev_state;
         /* offset 0x10 to 0x1f reserved for HC internal use */
-        u32     reserved[4];
+        __le32  reserved[4];
 };
 
 /* dev_info bitmasks */
@@ -580,12 +580,12 @@ struct xhci_slot_ctx {
  * reserved at the end of the endpoint context for HC internal use.
  */
 struct xhci_ep_ctx {
-        u32     ep_info;
-        u32     ep_info2;
-        u64     deq;
-        u32     tx_info;
+        __le32  ep_info;
+        __le32  ep_info2;
+        __le64  deq;
+        __le32  tx_info;
         /* offset 0x14 - 0x1f reserved for HC internal use */
-        u32     reserved[3];
+        __le32  reserved[3];
 };
 
 /* ep_info bitmasks */
@@ -660,9 +660,9 @@ struct xhci_ep_ctx {
  * @add_context:        set the bit of the endpoint context you want to enable
  */
 struct xhci_input_control_ctx {
-        u32     drop_flags;
-        u32     add_flags;
-        u32     rsvd2[6];
+        __le32  drop_flags;
+        __le32  add_flags;
+        __le32  rsvd2[6];
 };
 
 /* Represents everything that is needed to issue a command on the command ring.
@@ -688,9 +688,9 @@ struct xhci_command {
 
 struct xhci_stream_ctx {
         /* 64-bit stream ring address, cycle state, and stream type */
-        u64     stream_ring;
+        __le64  stream_ring;
         /* offset 0x14 - 0x1f reserved for HC internal use */
-        u32     reserved[2];
+        __le32  reserved[2];
 };
 
 /* Stream Context Types (section 6.4.1) - bits 3:1 of stream ctx deq ptr */
@@ -803,7 +803,7 @@ struct xhci_virt_device {
  */
 struct xhci_device_context_array {
         /* 64-bit device addresses; we only write 32-bit addresses */
-        u64                     dev_context_ptrs[MAX_HC_SLOTS];
+        __le64                  dev_context_ptrs[MAX_HC_SLOTS];
         /* private xHCD pointers */
         dma_addr_t      dma;
 };
@@ -816,10 +816,10 @@ struct xhci_device_context_array {
 
 struct xhci_transfer_event {
         /* 64-bit buffer address, or immediate data */
-        u64     buffer;
-        u32     transfer_len;
+        __le64  buffer;
+        __le32  transfer_len;
         /* This field is interpreted differently based on the type of TRB */
-        u32     flags;
+        __le32  flags;
 };
 
 /** Transfer Event bit fields **/
@@ -898,9 +898,9 @@ struct xhci_transfer_event {
 
 struct xhci_link_trb {
         /* 64-bit segment pointer*/
-        u64 segment_ptr;
-        u32 intr_target;
-        u32 control;
+        __le64 segment_ptr;
+        __le32 intr_target;
+        __le32 control;
 };
 
 /* control bitfields */
@@ -909,9 +909,9 @@ struct xhci_link_trb {
 /* Command completion event TRB */
 struct xhci_event_cmd {
         /* Pointer to command TRB, or the value passed by the event data trb */
-        u64 cmd_trb;
-        u32 status;
-        u32 flags;
+        __le64 cmd_trb;
+        __le32 status;
+        __le32 flags;
 };
 
 /* flags bitmasks */
@@ -943,6 +943,8 @@ struct xhci_event_cmd {
 /* Interrupter Target - which MSI-X vector to target the completion event at */
 #define TRB_INTR_TARGET(p)      (((p) & 0x3ff) << 22)
 #define GET_INTR_TARGET(p)      (((p) >> 22) & 0x3ff)
+#define TRB_TBC(p)              (((p) & 0x3) << 7)
+#define TRB_TLBPC(p)            (((p) & 0xf) << 16)
 
 /* Cycle bit - indicates TRB ownership by HC or HCD */
 #define TRB_CYCLE               (1<<0)
@@ -970,7 +972,7 @@ struct xhci_event_cmd {
 #define TRB_SIA                 (1<<31)
 
 struct xhci_generic_trb {
-        u32 field[4];
+        __le32 field[4];
 };
 
 union xhci_trb {
@@ -1118,10 +1120,10 @@ struct xhci_ring {
 
 struct xhci_erst_entry {
         /* 64-bit event ring segment address */
-        u64     seg_addr;
-        u32     seg_size;
+        __le64  seg_addr;
+        __le32  seg_size;
         /* Set to zero */
-        u32     rsvd;
+        __le32  rsvd;
 };
 
 struct xhci_erst {
@@ -1286,10 +1288,10 @@ struct xhci_hcd {
         /* Is each xHCI roothub port a USB 3.0, USB 2.0, or USB 1.1 port? */
         u8                      *port_array;
         /* Array of pointers to USB 3.0 PORTSC registers */
-        u32 __iomem             **usb3_ports;
+        __le32 __iomem          **usb3_ports;
         unsigned int            num_usb3_ports;
         /* Array of pointers to USB 2.0 PORTSC registers */
-        u32 __iomem             **usb2_ports;
+        __le32 __iomem          **usb2_ports;
         unsigned int            num_usb2_ports;
 };
 
@@ -1322,12 +1324,12 @@ static inline struct usb_hcd *xhci_to_hcd(struct xhci_hcd *xhci)
 /* TODO: copied from ehci.h - can be refactored? */
 /* xHCI spec says all registers are little endian */
 static inline unsigned int xhci_readl(const struct xhci_hcd *xhci,
-                __u32 __iomem *regs)
+                __le32 __iomem *regs)
 {
         return readl(regs);
 }
 static inline void xhci_writel(struct xhci_hcd *xhci,
-                const unsigned int val, __u32 __iomem *regs)
+                const unsigned int val, __le32 __iomem *regs)
 {
         xhci_dbg(xhci,
                         "`MEM_WRITE_DWORD(3'b000, 32'h%p, 32'h%0x, 4'hf);\n",
@@ -1345,7 +1347,7 @@ static inline void xhci_writel(struct xhci_hcd *xhci,
  * the high dword, and write order is irrelevant.
  */
 static inline u64 xhci_read_64(const struct xhci_hcd *xhci,
-                __u64 __iomem *regs)
+                __le64 __iomem *regs)
 {
         __u32 __iomem *ptr = (__u32 __iomem *) regs;
         u64 val_lo = readl(ptr);
@@ -1353,7 +1355,7 @@ static inline u64 xhci_read_64(const struct xhci_hcd *xhci,
         return val_lo + (val_hi << 32);
 }
 static inline void xhci_write_64(struct xhci_hcd *xhci,
-                const u64 val, __u64 __iomem *regs)
+                                 const u64 val, __le64 __iomem *regs)
 {
         __u32 __iomem *ptr = (__u32 __iomem *) regs;
         u32 val_lo = lower_32_bits(val);
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index 7839c98fa742..b16bd3ce3915 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -2889,8 +2889,7 @@ static struct usb_driver ftdi_elan_driver = {
 static int __init ftdi_elan_init(void)
 {
         int result;
-        printk(KERN_INFO "driver %s built at %s on %s\n", ftdi_elan_driver.name,
-               __TIME__, __DATE__);
+        printk(KERN_INFO "driver %s\n", ftdi_elan_driver.name);
         mutex_init(&ftdi_module_lock);
         INIT_LIST_HEAD(&ftdi_static_list);
         status_queue = create_singlethread_workqueue("ftdi-status-control");
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index eefb8275bb7e..cb4096201e29 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -20,11 +20,6 @@
  * Derived from Lego USB Tower driver
  * Copyright (C) 2003 David Glance <advidgsf@sourceforge.net>
  *               2001-2004 Juergen Stuber <starblue@users.sourceforge.net>
- *
- * V0.1  (mh) Initial version
- * V0.11 (mh) Added raw support for HID 1.0 devices (no interrupt out endpoint)
- * V0.12 (mh) Added kmalloc check for string buffer
- * V0.13 (mh) Added support for LD X-Ray and Machine Test System
  */
 
 #include <linux/kernel.h>
@@ -41,20 +36,39 @@
 
 /* Define these values to match your devices */
 #define USB_VENDOR_ID_LD                0x0f11  /* USB Vendor ID of LD Didactic GmbH */
-#define USB_DEVICE_ID_LD_CASSY          0x1000  /* USB Product ID of CASSY-S */
+#define USB_DEVICE_ID_LD_CASSY          0x1000  /* USB Product ID of CASSY-S modules with 8 bytes endpoint size */
+#define USB_DEVICE_ID_LD_CASSY2         0x1001  /* USB Product ID of CASSY-S modules with 64 bytes endpoint size */
 #define USB_DEVICE_ID_LD_POCKETCASSY    0x1010  /* USB Product ID of Pocket-CASSY */
+#define USB_DEVICE_ID_LD_POCKETCASSY2   0x1011  /* USB Product ID of Pocket-CASSY 2 (reserved) */
 #define USB_DEVICE_ID_LD_MOBILECASSY    0x1020  /* USB Product ID of Mobile-CASSY */
+#define USB_DEVICE_ID_LD_MOBILECASSY2   0x1021  /* USB Product ID of Mobile-CASSY 2 (reserved) */
+#define USB_DEVICE_ID_LD_MICROCASSYVOLTAGE      0x1031  /* USB Product ID of Micro-CASSY Voltage */
+#define USB_DEVICE_ID_LD_MICROCASSYCURRENT      0x1032  /* USB Product ID of Micro-CASSY Current */
+#define USB_DEVICE_ID_LD_MICROCASSYTIME         0x1033  /* USB Product ID of Micro-CASSY Time (reserved) */
+#define USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE  0x1035  /* USB Product ID of Micro-CASSY Temperature */
+#define USB_DEVICE_ID_LD_MICROCASSYPH           0x1038  /* USB Product ID of Micro-CASSY pH */
 #define USB_DEVICE_ID_LD_JWM            0x1080  /* USB Product ID of Joule and Wattmeter */
 #define USB_DEVICE_ID_LD_DMMP           0x1081  /* USB Product ID of Digital Multimeter P (reserved) */
 #define USB_DEVICE_ID_LD_UMIP           0x1090  /* USB Product ID of UMI P */
-#define USB_DEVICE_ID_LD_XRAY1          0x1100  /* USB Product ID of X-Ray Apparatus */
-#define USB_DEVICE_ID_LD_XRAY2          0x1101  /* USB Product ID of X-Ray Apparatus */
+#define USB_DEVICE_ID_LD_UMIC           0x10A0  /* USB Product ID of UMI C */
+#define USB_DEVICE_ID_LD_UMIB           0x10B0  /* USB Product ID of UMI B */
+#define USB_DEVICE_ID_LD_XRAY           0x1100  /* USB Product ID of X-Ray Apparatus 55481 */
+#define USB_DEVICE_ID_LD_XRAY2          0x1101  /* USB Product ID of X-Ray Apparatus 554800 */
+#define USB_DEVICE_ID_LD_XRAYCT         0x1110  /* USB Product ID of X-Ray Apparatus CT 554821*/
 #define USB_DEVICE_ID_LD_VIDEOCOM       0x1200  /* USB Product ID of VideoCom */
+#define USB_DEVICE_ID_LD_MOTOR          0x1210  /* USB Product ID of Motor (reserved) */
 #define USB_DEVICE_ID_LD_COM3LAB        0x2000  /* USB Product ID of COM3LAB */
 #define USB_DEVICE_ID_LD_TELEPORT       0x2010  /* USB Product ID of Terminal Adapter */
 #define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020 /* USB Product ID of Network Analyser */
 #define USB_DEVICE_ID_LD_POWERCONTROL   0x2030  /* USB Product ID of Converter Control Unit */
 #define USB_DEVICE_ID_LD_MACHINETEST    0x2040  /* USB Product ID of Machine Test System */
+#define USB_DEVICE_ID_LD_MOSTANALYSER   0x2050  /* USB Product ID of MOST Protocol Analyser */
+#define USB_DEVICE_ID_LD_MOSTANALYSER2  0x2051  /* USB Product ID of MOST Protocol Analyser 2 */
+#define USB_DEVICE_ID_LD_ABSESP         0x2060  /* USB Product ID of ABS ESP */
+#define USB_DEVICE_ID_LD_AUTODATABUS    0x2070  /* USB Product ID of Automotive Data Buses */
+#define USB_DEVICE_ID_LD_MCT            0x2080  /* USB Product ID of Microcontroller technique */
+#define USB_DEVICE_ID_LD_HYBRID         0x2090  /* USB Product ID of Automotive Hybrid */
+#define USB_DEVICE_ID_LD_HEATCONTROL    0x20A0  /* USB Product ID of Heat control */
 
 #define USB_VENDOR_ID_VERNIER           0x08f7
 #define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
@@ -71,19 +85,37 @@
 /* table of devices that work with this driver */
 static const struct usb_device_id ld_usb_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },
-        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY1) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIC) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOTOR) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
+        { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
@@ -91,7 +123,7 @@ static const struct usb_device_id ld_usb_table[] = {
         { }                                     /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, ld_usb_table);
-MODULE_VERSION("V0.13");
+MODULE_VERSION("V0.14");
 MODULE_AUTHOR("Michael Hund <mhund@ld-didactic.de>");
 MODULE_DESCRIPTION("LD USB Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index 388cc128072a..7e0bb2af8e63 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -1030,6 +1030,8 @@ test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param *param)
                         req.wValue = cpu_to_le16((USB_DT_DEVICE << 8) | 0);
                         /* device descriptor size == 18 bytes */
                         len = udev->descriptor.bMaxPacketSize0;
+                        if (udev->speed == USB_SPEED_SUPER)
+                                len = 512;
                         switch (len) {
                         case 8:
                                 len = 24;
@@ -1195,6 +1197,104 @@ static int unlink_simple(struct usbtest_dev *dev, int pipe, int len)
 
 /*-------------------------------------------------------------------------*/
 
+struct queued_ctx {
+        struct completion       complete;
+        atomic_t                pending;
+        unsigned                num;
+        int                     status;
+        struct urb              **urbs;
+};
+
+static void unlink_queued_callback(struct urb *urb)
+{
+        int                     status = urb->status;
+        struct queued_ctx       *ctx = urb->context;
+
+        if (ctx->status)
+                goto done;
+        if (urb == ctx->urbs[ctx->num - 4] || urb == ctx->urbs[ctx->num - 2]) {
+                if (status == -ECONNRESET)
+                        goto done;
+                /* What error should we report if the URB completed normally? */
+        }
+        if (status != 0)
+                ctx->status = status;
+
+ done:
+        if (atomic_dec_and_test(&ctx->pending))
+                complete(&ctx->complete);
+}
+
+static int unlink_queued(struct usbtest_dev *dev, int pipe, unsigned num,
+                unsigned size)
+{
+        struct queued_ctx       ctx;
+        struct usb_device       *udev = testdev_to_usbdev(dev);
+        void                    *buf;
+        dma_addr_t              buf_dma;
+        int                     i;
+        int                     retval = -ENOMEM;
+
+        init_completion(&ctx.complete);
+        atomic_set(&ctx.pending, 1);    /* One more than the actual value */
+        ctx.num = num;
+        ctx.status = 0;
+
+        buf = usb_alloc_coherent(udev, size, GFP_KERNEL, &buf_dma);
+        if (!buf)
+                return retval;
+        memset(buf, 0, size);
+
+        /* Allocate and init the urbs we'll queue */
+        ctx.urbs = kcalloc(num, sizeof(struct urb *), GFP_KERNEL);
+        if (!ctx.urbs)
+                goto free_buf;
+        for (i = 0; i < num; i++) {
+                ctx.urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
+                if (!ctx.urbs[i])
+                        goto free_urbs;
+                usb_fill_bulk_urb(ctx.urbs[i], udev, pipe, buf, size,
+                                unlink_queued_callback, &ctx);
+                ctx.urbs[i]->transfer_dma = buf_dma;
+                ctx.urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+        }
+
+        /* Submit all the URBs and then unlink URBs num - 4 and num - 2. */
+        for (i = 0; i < num; i++) {
+                atomic_inc(&ctx.pending);
+                retval = usb_submit_urb(ctx.urbs[i], GFP_KERNEL);
+                if (retval != 0) {
+                        dev_err(&dev->intf->dev, "submit urbs[%d] fail %d\n",
+                                        i, retval);
+                        atomic_dec(&ctx.pending);
+                        ctx.status = retval;
+                        break;
+                }
+        }
+        if (i == num) {
+                usb_unlink_urb(ctx.urbs[num - 4]);
+                usb_unlink_urb(ctx.urbs[num - 2]);
+        } else {
+                while (--i >= 0)
+                        usb_unlink_urb(ctx.urbs[i]);
+        }
+
+        if (atomic_dec_and_test(&ctx.pending))          /* The extra count */
+                complete(&ctx.complete);
+        wait_for_completion(&ctx.complete);
+        retval = ctx.status;
+
+ free_urbs:
+        for (i = 0; i < num; i++)
+                usb_free_urb(ctx.urbs[i]);
+        kfree(ctx.urbs);
+ free_buf:
+        usb_free_coherent(udev, size, buf, buf_dma);
+        return retval;
+}
+
+/*-------------------------------------------------------------------------*/
+
 static int verify_not_halted(struct usbtest_dev *tdev, int ep, struct urb *urb)
 {
         int     retval;
@@ -1970,8 +2070,6 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
                                 dev->in_iso_pipe, dev->iso_in, 0);
                 break;
 
-        /* FIXME unlink from queue (ring with N urbs) */
-
         /* FIXME scatterlist cancel (needs helper thread) */
 
         /* Tests for bulk I/O using DMA mapping by core and odd address */
@@ -2064,6 +2162,26 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
                                 dev->in_iso_pipe, dev->iso_in, 1);
                 break;
 
+        /* unlink URBs from a bulk-OUT queue */
+        case 24:
+                if (dev->out_pipe == 0 || !param->length || param->sglen < 4)
+                        break;
+                retval = 0;
+                dev_info(&intf->dev, "TEST 17:  unlink from %d queues of "
+                                "%d %d-byte writes\n",
+                                param->iterations, param->sglen, param->length);
+                for (i = param->iterations; retval == 0 && i > 0; --i) {
+                        retval = unlink_queued(dev, dev->out_pipe,
+                                                param->sglen, param->length);
+                        if (retval) {
+                                dev_err(&intf->dev,
+                                        "unlink queued writes failed %d, "
+                                        "iterations left %d\n", retval, i);
+                                break;
+                        }
+                }
+                break;
+
         }
         do_gettimeofday(&param->duration);
         param->duration.tv_sec -= start.tv_sec;
@@ -2192,6 +2310,9 @@ usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id)
                         case USB_SPEED_HIGH:
                                 tmp = "high";
                                 break;
+                        case USB_SPEED_SUPER:
+                                tmp = "super";
+                                break;
                         default:
                                 tmp = "unknown";
                                 break;
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index d5a3da37c90c..9e6209f87d3b 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -151,7 +151,8 @@ static void otg_timer(unsigned long _musb)
          * status change events (from the transceiver) otherwise.
          */
         devctl = musb_readb(mregs, MUSB_DEVCTL);
-        DBG(7, "Poll devctl %02x (%s)\n", devctl, otg_state_string(musb));
+        DBG(7, "Poll devctl %02x (%s)\n", devctl,
+                otg_state_string(musb->xceiv->state));
 
         spin_lock_irqsave(&musb->lock, flags);
         switch (musb->xceiv->state) {
@@ -202,7 +203,8 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout)
         /* Never idle if active, or when VBUS timeout is not set as host */
         if (musb->is_active || (musb->a_wait_bcon == 0 &&
                                 musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
-                DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+                DBG(4, "%s active, deleting timer\n",
+                        otg_state_string(musb->xceiv->state));
                 del_timer(&otg_workaround);
                 last_timer = jiffies;
                 return;
@@ -215,7 +217,8 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout)
         last_timer = timeout;
 
         DBG(4, "%s inactive, starting idle timer for %u ms\n",
-            otg_state_string(musb), jiffies_to_msecs(timeout - jiffies));
+                otg_state_string(musb->xceiv->state),
+                jiffies_to_msecs(timeout - jiffies));
         mod_timer(&otg_workaround, timeout);
 }
 
@@ -304,7 +307,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
                 /* NOTE: this must complete power-on within 100 ms. */
                 DBG(2, "VBUS %s (%s)%s, devctl %02x\n",
                                 drvvbus ? "on" : "off",
-                                otg_state_string(musb),
+                                otg_state_string(musb->xceiv->state),
                                 err ? " ERROR" : "",
                                 devctl);
                 ret = IRQ_HANDLED;
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index 8e2a1ff8a35a..e141d89656e1 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -279,12 +279,13 @@ static void musb_conn_timer_handler(unsigned long _musb)
                 }
                 break;
         default:
-                DBG(1, "%s state not handled\n", otg_state_string(musb));
+                DBG(1, "%s state not handled\n",
+                        otg_state_string(musb->xceiv->state));
                 break;
         }
         spin_unlock_irqrestore(&musb->lock, flags);
 
-        DBG(4, "state is %s\n", otg_state_string(musb));
+        DBG(4, "state is %s\n", otg_state_string(musb->xceiv->state));
 }
 
 static void bfin_musb_enable(struct musb *musb)
@@ -308,7 +309,7 @@ static void bfin_musb_set_vbus(struct musb *musb, int is_on)
 
         DBG(1, "VBUS %s, devctl %02x "
                 /* otg %3x conf %08x prcm %08x */ "\n",
-                otg_state_string(musb),
+                otg_state_string(musb->xceiv->state),
                 musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index 69a0da3c8f09..0d8984993a38 100644
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -199,7 +199,8 @@ static void otg_timer(unsigned long _musb)
          * status change events (from the transceiver) otherwise.
          */
         devctl = musb_readb(mregs, MUSB_DEVCTL);
-        DBG(7, "Poll devctl %02x (%s)\n", devctl, otg_state_string(musb));
+        DBG(7, "Poll devctl %02x (%s)\n", devctl,
+                otg_state_string(musb->xceiv->state));
 
         spin_lock_irqsave(&musb->lock, flags);
         switch (musb->xceiv->state) {
@@ -273,7 +274,8 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout)
         /* Never idle if active, or when VBUS timeout is not set as host */
         if (musb->is_active || (musb->a_wait_bcon == 0 &&
                                 musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
-                DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+                DBG(4, "%s active, deleting timer\n",
+                        otg_state_string(musb->xceiv->state));
                 del_timer(&otg_workaround);
                 last_timer = jiffies;
                 return;
@@ -286,7 +288,8 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout)
         last_timer = timeout;
 
         DBG(4, "%s inactive, starting idle timer for %u ms\n",
-            otg_state_string(musb), jiffies_to_msecs(timeout - jiffies));
+                otg_state_string(musb->xceiv->state),
+                jiffies_to_msecs(timeout - jiffies));
         mod_timer(&otg_workaround, timeout);
 }
 
@@ -365,7 +368,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
 
                 DBG(2, "VBUS %s (%s)%s, devctl %02x\n",
                                 drvvbus ? "on" : "off",
-                                otg_state_string(musb),
+                                otg_state_string(musb->xceiv->state),
                                 err ? " ERROR" : "",
                                 devctl);
                 ret = IRQ_HANDLED;
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index e6de097fb7e8..3661b81a9571 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -220,7 +220,8 @@ static void otg_timer(unsigned long _musb)
         * status change events (from the transceiver) otherwise.
          */
         devctl = musb_readb(mregs, MUSB_DEVCTL);
-        DBG(7, "poll devctl %02x (%s)\n", devctl, otg_state_string(musb));
+        DBG(7, "poll devctl %02x (%s)\n", devctl,
+                otg_state_string(musb->xceiv->state));
 
         spin_lock_irqsave(&musb->lock, flags);
         switch (musb->xceiv->state) {
@@ -356,7 +357,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
                 davinci_musb_source_power(musb, drvvbus, 0);
                 DBG(2, "VBUS %s (%s)%s, devctl %02x\n",
                                 drvvbus ? "on" : "off",
-                                otg_state_string(musb),
+                                otg_state_string(musb->xceiv->state),
                                 err ? " ERROR" : "",
                                 devctl);
                 retval = IRQ_HANDLED;
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index f10ff00ca09e..9a280872c2b4 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -333,26 +333,6 @@ void musb_load_testpacket(struct musb *musb)
 
 /*-------------------------------------------------------------------------*/
 
-const char *otg_state_string(struct musb *musb)
-{
-        switch (musb->xceiv->state) {
-        case OTG_STATE_A_IDLE:          return "a_idle";
-        case OTG_STATE_A_WAIT_VRISE:    return "a_wait_vrise";
-        case OTG_STATE_A_WAIT_BCON:     return "a_wait_bcon";
-        case OTG_STATE_A_HOST:          return "a_host";
-        case OTG_STATE_A_SUSPEND:       return "a_suspend";
-        case OTG_STATE_A_PERIPHERAL:    return "a_peripheral";
-        case OTG_STATE_A_WAIT_VFALL:    return "a_wait_vfall";
-        case OTG_STATE_A_VBUS_ERR:      return "a_vbus_err";
-        case OTG_STATE_B_IDLE:          return "b_idle";
-        case OTG_STATE_B_SRP_INIT:      return "b_srp_init";
-        case OTG_STATE_B_PERIPHERAL:    return "b_peripheral";
-        case OTG_STATE_B_WAIT_ACON:     return "b_wait_acon";
-        case OTG_STATE_B_HOST:          return "b_host";
-        default:                        return "UNDEFINED";
-        }
-}
-
 #ifdef  CONFIG_USB_MUSB_OTG
 
 /*
@@ -373,12 +353,14 @@ void musb_otg_timer_func(unsigned long data)
                 break;
         case OTG_STATE_A_SUSPEND:
         case OTG_STATE_A_WAIT_BCON:
-                DBG(1, "HNP: %s timeout\n", otg_state_string(musb));
+                DBG(1, "HNP: %s timeout\n",
+                        otg_state_string(musb->xceiv->state));
                 musb_platform_set_vbus(musb, 0);
                 musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
                 break;
         default:
-                DBG(1, "HNP: Unhandled mode %s\n", otg_state_string(musb));
+                DBG(1, "HNP: Unhandled mode %s\n",
+                        otg_state_string(musb->xceiv->state));
         }
         musb->ignore_disconnect = 0;
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -393,12 +375,13 @@ void musb_hnp_stop(struct musb *musb)
         void __iomem    *mbase = musb->mregs;
         u8      reg;
 
-        DBG(1, "HNP: stop from %s\n", otg_state_string(musb));
+        DBG(1, "HNP: stop from %s\n", otg_state_string(musb->xceiv->state));
 
         switch (musb->xceiv->state) {
         case OTG_STATE_A_PERIPHERAL:
                 musb_g_disconnect(musb);
-                DBG(1, "HNP: back to %s\n", otg_state_string(musb));
+                DBG(1, "HNP: back to %s\n",
+                        otg_state_string(musb->xceiv->state));
                 break;
         case OTG_STATE_B_HOST:
                 DBG(1, "HNP: Disabling HR\n");
@@ -412,7 +395,7 @@ void musb_hnp_stop(struct musb *musb)
                 break;
         default:
                 DBG(1, "HNP: Stopping in unknown state %s\n",
-                        otg_state_string(musb));
+                        otg_state_string(musb->xceiv->state));
         }
 
         /*
@@ -451,7 +434,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
          */
         if (int_usb & MUSB_INTR_RESUME) {
                 handled = IRQ_HANDLED;
-                DBG(3, "RESUME (%s)\n", otg_state_string(musb));
+                DBG(3, "RESUME (%s)\n", otg_state_string(musb->xceiv->state));
 
                 if (devctl & MUSB_DEVCTL_HM) {
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
@@ -492,7 +475,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         default:
                                 WARNING("bogus %s RESUME (%s)\n",
                                         "host",
-                                        otg_state_string(musb));
+                                        otg_state_string(musb->xceiv->state));
                         }
 #endif
                 } else {
@@ -526,7 +509,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         default:
                                 WARNING("bogus %s RESUME (%s)\n",
                                         "peripheral",
-                                        otg_state_string(musb));
+                                        otg_state_string(musb->xceiv->state));
                         }
                 }
         }
@@ -542,7 +525,8 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         return IRQ_HANDLED;
                 }
 
-                DBG(1, "SESSION_REQUEST (%s)\n", otg_state_string(musb));
+                DBG(1, "SESSION_REQUEST (%s)\n",
+                        otg_state_string(musb->xceiv->state));
 
                 /* IRQ arrives from ID pin sense or (later, if VBUS power
                  * is removed) SRP.  responses are time critical:
@@ -607,7 +591,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 }
 
                 DBG(1, "VBUS_ERROR in %s (%02x, %s), retry #%d, port1 %08x\n",
-                                otg_state_string(musb),
+                                otg_state_string(musb->xceiv->state),
                                 devctl,
                                 ({ char *s;
                                 switch (devctl & MUSB_DEVCTL_VBUS) {
@@ -633,7 +617,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 #endif
         if (int_usb & MUSB_INTR_SUSPEND) {
                 DBG(1, "SUSPEND (%s) devctl %02x power %02x\n",
-                                otg_state_string(musb), devctl, power);
+                        otg_state_string(musb->xceiv->state), devctl, power);
                 handled = IRQ_HANDLED;
 
                 switch (musb->xceiv->state) {
@@ -758,13 +742,13 @@ b_host:
                         usb_hcd_resume_root_hub(hcd);
 
                 DBG(1, "CONNECT (%s) devctl %02x\n",
-                                otg_state_string(musb), devctl);
+                                otg_state_string(musb->xceiv->state), devctl);
         }
 #endif  /* CONFIG_USB_MUSB_HDRC_HCD */
 
         if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) {
                 DBG(1, "DISCONNECT (%s) as %s, devctl %02x\n",
-                                otg_state_string(musb),
+                                otg_state_string(musb->xceiv->state),
                                 MUSB_MODE(musb), devctl);
                 handled = IRQ_HANDLED;
 
@@ -807,7 +791,7 @@ b_host:
 #endif  /* GADGET */
                 default:
                         WARNING("unhandled DISCONNECT transition (%s)\n",
-                                otg_state_string(musb));
+                                otg_state_string(musb->xceiv->state));
                         break;
                 }
         }
@@ -832,7 +816,8 @@ b_host:
                                 musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
                         }
                 } else if (is_peripheral_capable()) {
-                        DBG(1, "BUS RESET as %s\n", otg_state_string(musb));
+                        DBG(1, "BUS RESET as %s\n",
+                                otg_state_string(musb->xceiv->state));
                         switch (musb->xceiv->state) {
 #ifdef CONFIG_USB_OTG
                         case OTG_STATE_A_SUSPEND:
@@ -846,8 +831,8 @@ b_host:
                         case OTG_STATE_A_WAIT_BCON:     /* OPT TD.4.7-900ms */
                                 /* never use invalid T(a_wait_bcon) */
                                 DBG(1, "HNP: in %s, %d msec timeout\n",
-                                                otg_state_string(musb),
-                                                TA_WAIT_BCON(musb));
+                                        otg_state_string(musb->xceiv->state),
+                                        TA_WAIT_BCON(musb));
                                 mod_timer(&musb->otg_timer, jiffies
                                         + msecs_to_jiffies(TA_WAIT_BCON(musb)));
                                 break;
@@ -858,7 +843,7 @@ b_host:
                                 break;
                         case OTG_STATE_B_WAIT_ACON:
                                 DBG(1, "HNP: RESET (%s), to b_peripheral\n",
-                                        otg_state_string(musb));
+                                        otg_state_string(musb->xceiv->state));
                                 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                                 musb_g_reset(musb);
                                 break;
@@ -871,7 +856,7 @@ b_host:
                                 break;
                         default:
                                 DBG(1, "Unhandled BUS RESET as %s\n",
-                                        otg_state_string(musb));
+                                        otg_state_string(musb->xceiv->state));
                         }
                 }
         }
@@ -1713,7 +1698,7 @@ musb_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
         int ret = -EINVAL;
 
         spin_lock_irqsave(&musb->lock, flags);
-        ret = sprintf(buf, "%s\n", otg_state_string(musb));
+        ret = sprintf(buf, "%s\n", otg_state_string(musb->xceiv->state));
         spin_unlock_irqrestore(&musb->lock, flags);
 
         return ret;
diff --git a/drivers/usb/musb/musb_debug.h b/drivers/usb/musb/musb_debug.h
index 94f6973cf8f7..f958a49a0124 100644
--- a/drivers/usb/musb/musb_debug.h
+++ b/drivers/usb/musb/musb_debug.h
@@ -54,8 +54,6 @@ static inline int _dbg_level(unsigned l)
         return musb_debug >= l;
 }
 
-extern const char *otg_state_string(struct musb *);
-
 #ifdef CONFIG_DEBUG_FS
 extern int musb_init_debugfs(struct musb *musb);
 extern void musb_exit_debugfs(struct musb *musb);
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index f47c20197c61..cfbee4dcfc13 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1556,7 +1556,8 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
                 status = 0;
                 goto done;
         default:
-                DBG(2, "Unhandled wake: %s\n", otg_state_string(musb));
+                DBG(2, "Unhandled wake: %s\n",
+                        otg_state_string(musb->xceiv->state));
                 goto done;
         }
 
@@ -2037,7 +2038,7 @@ void musb_g_resume(struct musb *musb)
                 break;
         default:
                 WARNING("unhandled RESUME transition (%s)\n",
-                                otg_state_string(musb));
+                                otg_state_string(musb->xceiv->state));
         }
 }
 
@@ -2067,7 +2068,7 @@ void musb_g_suspend(struct musb *musb)
                  * A_PERIPHERAL may need care too
                  */
                 WARNING("unhandled SUSPEND transition (%s)\n",
-                                otg_state_string(musb));
+                                otg_state_string(musb->xceiv->state));
         }
 }
 
@@ -2102,7 +2103,7 @@ void musb_g_disconnect(struct musb *musb)
         default:
 #ifdef  CONFIG_USB_MUSB_OTG
                 DBG(2, "Unhandled disconnect %s, setting a_idle\n",
-                        otg_state_string(musb));
+                        otg_state_string(musb->xceiv->state));
                 musb->xceiv->state = OTG_STATE_A_IDLE;
                 MUSB_HST_MODE(musb);
                 break;
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 5eef4a8847db..07b106c7de82 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -2304,7 +2304,7 @@ static int musb_bus_suspend(struct usb_hcd *hcd)
 
         if (musb->is_active) {
                 WARNING("trying to suspend as %s while active\n",
-                                otg_state_string(musb));
+                                otg_state_string(musb->xceiv->state));
                 return -EBUSY;
         } else
                 return 0;
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index 489104a5ae14..bb1247d5fd04 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -98,7 +98,7 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
 #endif
                 default:
                         DBG(1, "bogus rh suspend? %s\n",
-                                otg_state_string(musb));
+                                otg_state_string(musb->xceiv->state));
                 }
         } else if (power & MUSB_POWER_SUSPENDM) {
                 power &= ~MUSB_POWER_SUSPENDM;
@@ -208,7 +208,8 @@ void musb_root_disconnect(struct musb *musb)
                 musb->xceiv->state = OTG_STATE_B_IDLE;
                 break;
         default:
-                DBG(1, "host disconnect (%s)\n", otg_state_string(musb));
+                DBG(1, "host disconnect (%s)\n",
+                        otg_state_string(musb->xceiv->state));
         }
 }
 
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index e9e60b6e0583..b996fec84c29 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -114,7 +114,8 @@ static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout)
         /* Never idle if active, or when VBUS timeout is not set as host */
         if (musb->is_active || ((musb->a_wait_bcon == 0)
                         && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) {
-                DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+                DBG(4, "%s active, deleting timer\n",
+                        otg_state_string(musb->xceiv->state));
                 del_timer(&musb_idle_timer);
                 last_timer = jiffies;
                 return;
@@ -131,7 +132,7 @@ static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout)
         last_timer = timeout;
 
         DBG(4, "%s inactive, for idle timer for %lu ms\n",
-                otg_state_string(musb),
+                otg_state_string(musb->xceiv->state),
                 (unsigned long)jiffies_to_msecs(timeout - jiffies));
         mod_timer(&musb_idle_timer, timeout);
 }
@@ -195,7 +196,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
 
         DBG(1, "VBUS %s, devctl %02x "
                 /* otg %3x conf %08x prcm %08x */ "\n",
-                otg_state_string(musb),
+                otg_state_string(musb->xceiv->state),
                 musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index c47aac4a1f98..221feaaded72 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -422,7 +422,7 @@ static void musb_do_idle(unsigned long _musb)
                         && (musb->idle_timeout == 0
                                 || time_after(jiffies, musb->idle_timeout))) {
                         DBG(4, "Nothing connected %s, turning off VBUS\n",
-                                        otg_state_string(musb));
+                                        otg_state_string(musb->xceiv->state));
                 }
                 /* FALLTHROUGH */
         case OTG_STATE_A_IDLE:
@@ -481,7 +481,8 @@ static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout)
         /* Never idle if active, or when VBUS timeout is not set as host */
         if (musb->is_active || ((musb->a_wait_bcon == 0)
                         && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) {
-                DBG(4, "%s active, deleting timer\n", otg_state_string(musb));
+                DBG(4, "%s active, deleting timer\n",
+                        otg_state_string(musb->xceiv->state));
                 del_timer(&musb_idle_timer);
                 last_timer = jiffies;
                 return;
@@ -498,7 +499,7 @@ static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout)
         last_timer = timeout;
 
         DBG(4, "%s inactive, for idle timer for %lu ms\n",
-                otg_state_string(musb),
+                otg_state_string(musb->xceiv->state),
                 (unsigned long)jiffies_to_msecs(timeout - jiffies));
         mod_timer(&musb_idle_timer, timeout);
 }
@@ -573,7 +574,7 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on)
         musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 
         DBG(1, "VBUS %s, devctl %02x otg %3x conf %08x prcm %08x\n",
-                otg_state_string(musb),
+                otg_state_string(musb->xceiv->state),
                 musb_readb(musb->mregs, MUSB_DEVCTL),
                 musb_readl(tbase, TUSB_DEV_OTG_STAT),
                 conf, prcm);
@@ -702,13 +703,13 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                                 musb->is_active = 0;
                         }
                         DBG(2, "vbus change, %s, otg %03x\n",
-                                otg_state_string(musb), otg_stat);
+                                otg_state_string(musb->xceiv->state), otg_stat);
                         idle_timeout = jiffies + (1 * HZ);
                         schedule_work(&musb->irq_work);
 
                 } else /* A-dev state machine */ {
                         DBG(2, "vbus change, %s, otg %03x\n",
-                                otg_state_string(musb), otg_stat);
+                                otg_state_string(musb->xceiv->state), otg_stat);
 
                         switch (musb->xceiv->state) {
                         case OTG_STATE_A_IDLE:
@@ -756,7 +757,8 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
         if (int_src & TUSB_INT_SRC_OTG_TIMEOUT) {
                 u8      devctl;
 
-                DBG(4, "%s timer, %03x\n", otg_state_string(musb), otg_stat);
+                DBG(4, "%s timer, %03x\n",
+                        otg_state_string(musb->xceiv->state), otg_stat);
 
                 switch (musb->xceiv->state) {
                 case OTG_STATE_A_WAIT_VRISE:
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig
index daf3e5f1a0e7..c66481ad98d7 100644
--- a/drivers/usb/otg/Kconfig
+++ b/drivers/usb/otg/Kconfig
@@ -122,4 +122,12 @@ config AB8500_USB
           This transceiver supports high and full speed devices plus,
           in host mode, low speed.
 
+config FSL_USB2_OTG
+        bool "Freescale USB OTG Transceiver Driver"
+        depends on USB_EHCI_FSL && USB_GADGET_FSL_USB2
+        select USB_OTG
+        select USB_OTG_UTILS
+        help
+          Enable this to support Freescale USB OTG transceiver.
+
 endif # USB || OTG
diff --git a/drivers/usb/otg/Makefile b/drivers/usb/otg/Makefile
index e22d917de017..566655c53331 100644
--- a/drivers/usb/otg/Makefile
+++ b/drivers/usb/otg/Makefile
@@ -19,3 +19,5 @@ obj-$(CONFIG_USB_ULPI)		+= ulpi.o
 obj-$(CONFIG_USB_ULPI_VIEWPORT) += ulpi_viewport.o
 obj-$(CONFIG_USB_MSM_OTG)       += msm_otg.o
 obj-$(CONFIG_AB8500_USB)        += ab8500-usb.o
+fsl_usb2_otg-objs               := fsl_otg.o otg_fsm.o
+obj-$(CONFIG_FSL_USB2_OTG)      += fsl_usb2_otg.o
diff --git a/drivers/usb/otg/fsl_otg.c b/drivers/usb/otg/fsl_otg.c
new file mode 100644
index 000000000000..0f420b25e9a9
--- /dev/null
+++ b/drivers/usb/otg/fsl_otg.c
@@ -0,0 +1,1169 @@
+/*
+ * Copyright (C) 2007,2008 Freescale semiconductor, Inc.
+ *
+ * Author: Li Yang <LeoLi@freescale.com>
+ *         Jerry Huang <Chang-Ming.Huang@freescale.com>
+ *
+ * Initialization based on code from Shlomi Gridish.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the  GNU General Public License along
+ * with this program; if not, write  to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/proc_fs.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/timer.h>
+#include <linux/usb.h>
+#include <linux/device.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/workqueue.h>
+#include <linux/time.h>
+#include <linux/fsl_devices.h>
+#include <linux/platform_device.h>
+#include <linux/uaccess.h>
+
+#include <asm/unaligned.h>
+
+#include "fsl_otg.h"
+
+#define DRIVER_VERSION "Rev. 1.55"
+#define DRIVER_AUTHOR "Jerry Huang/Li Yang"
+#define DRIVER_DESC "Freescale USB OTG Transceiver Driver"
+#define DRIVER_INFO DRIVER_DESC " " DRIVER_VERSION
+
+static const char driver_name[] = "fsl-usb2-otg";
+
+const pm_message_t otg_suspend_state = {
+        .event = 1,
+};
+
+#define HA_DATA_PULSE
+
+static struct usb_dr_mmap *usb_dr_regs;
+static struct fsl_otg *fsl_otg_dev;
+static int srp_wait_done;
+
+/* FSM timers */
+struct fsl_otg_timer *a_wait_vrise_tmr, *a_wait_bcon_tmr, *a_aidl_bdis_tmr,
+        *b_ase0_brst_tmr, *b_se0_srp_tmr;
+
+/* Driver specific timers */
+struct fsl_otg_timer *b_data_pulse_tmr, *b_vbus_pulse_tmr, *b_srp_fail_tmr,
+        *b_srp_wait_tmr, *a_wait_enum_tmr;
+
+static struct list_head active_timers;
+
+static struct fsl_otg_config fsl_otg_initdata = {
+        .otg_port = 1,
+};
+
+#ifdef CONFIG_PPC32
+static u32 _fsl_readl_be(const unsigned __iomem *p)
+{
+        return in_be32(p);
+}
+
+static u32 _fsl_readl_le(const unsigned __iomem *p)
+{
+        return in_le32(p);
+}
+
+static void _fsl_writel_be(u32 v, unsigned __iomem *p)
+{
+        out_be32(p, v);
+}
+
+static void _fsl_writel_le(u32 v, unsigned __iomem *p)
+{
+        out_le32(p, v);
+}
+
+static u32 (*_fsl_readl)(const unsigned __iomem *p);
+static void (*_fsl_writel)(u32 v, unsigned __iomem *p);
+
+#define fsl_readl(p)            (*_fsl_readl)((p))
+#define fsl_writel(v, p)        (*_fsl_writel)((v), (p))
+
+#else
+#define fsl_readl(addr)         readl(addr)
+#define fsl_writel(val, addr)   writel(val, addr)
+#endif /* CONFIG_PPC32 */
+
+/* Routines to access transceiver ULPI registers */
+u8 view_ulpi(u8 addr)
+{
+        u32 temp;
+
+        temp = 0x40000000 | (addr << 16);
+        fsl_writel(temp, &usb_dr_regs->ulpiview);
+        udelay(1000);
+        while (temp & 0x40)
+                temp = fsl_readl(&usb_dr_regs->ulpiview);
+        return (le32_to_cpu(temp) & 0x0000ff00) >> 8;
+}
+
+int write_ulpi(u8 addr, u8 data)
+{
+        u32 temp;
+
+        temp = 0x60000000 | (addr << 16) | data;
+        fsl_writel(temp, &usb_dr_regs->ulpiview);
+        return 0;
+}
+
+/* -------------------------------------------------------------*/
+/* Operations that will be called from OTG Finite State Machine */
+
+/* Charge vbus for vbus pulsing in SRP */
+void fsl_otg_chrg_vbus(int on)
+{
+        u32 tmp;
+
+        tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
+
+        if (on)
+                /* stop discharging, start charging */
+                tmp = (tmp & ~OTGSC_CTRL_VBUS_DISCHARGE) |
+                        OTGSC_CTRL_VBUS_CHARGE;
+        else
+                /* stop charging */
+                tmp &= ~OTGSC_CTRL_VBUS_CHARGE;
+
+        fsl_writel(tmp, &usb_dr_regs->otgsc);
+}
+
+/* Discharge vbus through a resistor to ground */
+void fsl_otg_dischrg_vbus(int on)
+{
+        u32 tmp;
+
+        tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
+
+        if (on)
+                /* stop charging, start discharging */
+                tmp = (tmp & ~OTGSC_CTRL_VBUS_CHARGE) |
+                        OTGSC_CTRL_VBUS_DISCHARGE;
+        else
+                /* stop discharging */
+                tmp &= ~OTGSC_CTRL_VBUS_DISCHARGE;
+
+        fsl_writel(tmp, &usb_dr_regs->otgsc);
+}
+
+/* A-device driver vbus, controlled through PP bit in PORTSC */
+void fsl_otg_drv_vbus(int on)
+{
+        u32 tmp;
+
+        if (on) {
+                tmp = fsl_readl(&usb_dr_regs->portsc) & ~PORTSC_W1C_BITS;
+                fsl_writel(tmp | PORTSC_PORT_POWER, &usb_dr_regs->portsc);
+        } else {
+                tmp = fsl_readl(&usb_dr_regs->portsc) &
+                      ~PORTSC_W1C_BITS & ~PORTSC_PORT_POWER;
+                fsl_writel(tmp, &usb_dr_regs->portsc);
+        }
+}
+
+/*
+ * Pull-up D+, signalling connect by periperal. Also used in
+ * data-line pulsing in SRP
+ */
+void fsl_otg_loc_conn(int on)
+{
+        u32 tmp;
+
+        tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
+
+        if (on)
+                tmp |= OTGSC_CTRL_DATA_PULSING;
+        else
+                tmp &= ~OTGSC_CTRL_DATA_PULSING;
+
+        fsl_writel(tmp, &usb_dr_regs->otgsc);
+}
+
+/*
+ * Generate SOF by host.  This is controlled through suspend/resume the
+ * port.  In host mode, controller will automatically send SOF.
+ * Suspend will block the data on the port.
+ */
+void fsl_otg_loc_sof(int on)
+{
+        u32 tmp;
+
+        tmp = fsl_readl(&fsl_otg_dev->dr_mem_map->portsc) & ~PORTSC_W1C_BITS;
+        if (on)
+                tmp |= PORTSC_PORT_FORCE_RESUME;
+        else
+                tmp |= PORTSC_PORT_SUSPEND;
+
+        fsl_writel(tmp, &fsl_otg_dev->dr_mem_map->portsc);
+
+}
+
+/* Start SRP pulsing by data-line pulsing, followed with v-bus pulsing. */
+void fsl_otg_start_pulse(void)
+{
+        u32 tmp;
+
+        srp_wait_done = 0;
+#ifdef HA_DATA_PULSE
+        tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
+        tmp |= OTGSC_HA_DATA_PULSE;
+        fsl_writel(tmp, &usb_dr_regs->otgsc);
+#else
+        fsl_otg_loc_conn(1);
+#endif
+
+        fsl_otg_add_timer(b_data_pulse_tmr);
+}
+
+void b_data_pulse_end(unsigned long foo)
+{
+#ifdef HA_DATA_PULSE
+#else
+        fsl_otg_loc_conn(0);
+#endif
+
+        /* Do VBUS pulse after data pulse */
+        fsl_otg_pulse_vbus();
+}
+
+void fsl_otg_pulse_vbus(void)
+{
+        srp_wait_done = 0;
+        fsl_otg_chrg_vbus(1);
+        /* start the timer to end vbus charge */
+        fsl_otg_add_timer(b_vbus_pulse_tmr);
+}
+
+void b_vbus_pulse_end(unsigned long foo)
+{
+        fsl_otg_chrg_vbus(0);
+
+        /*
+         * As USB3300 using the same a_sess_vld and b_sess_vld voltage
+         * we need to discharge the bus for a while to distinguish
+         * residual voltage of vbus pulsing and A device pull up
+         */
+        fsl_otg_dischrg_vbus(1);
+        fsl_otg_add_timer(b_srp_wait_tmr);
+}
+
+void b_srp_end(unsigned long foo)
+{
+        fsl_otg_dischrg_vbus(0);
+        srp_wait_done = 1;
+
+        if ((fsl_otg_dev->otg.state == OTG_STATE_B_SRP_INIT) &&
+            fsl_otg_dev->fsm.b_sess_vld)
+                fsl_otg_dev->fsm.b_srp_done = 1;
+}
+
+/*
+ * Workaround for a_host suspending too fast.  When a_bus_req=0,
+ * a_host will start by SRP.  It needs to set b_hnp_enable before
+ * actually suspending to start HNP
+ */
+void a_wait_enum(unsigned long foo)
+{
+        VDBG("a_wait_enum timeout\n");
+        if (!fsl_otg_dev->otg.host->b_hnp_enable)
+                fsl_otg_add_timer(a_wait_enum_tmr);
+        else
+                otg_statemachine(&fsl_otg_dev->fsm);
+}
+
+/* The timeout callback function to set time out bit */
+void set_tmout(unsigned long indicator)
+{
+        *(int *)indicator = 1;
+}
+
+/* Initialize timers */
+int fsl_otg_init_timers(struct otg_fsm *fsm)
+{
+        /* FSM used timers */
+        a_wait_vrise_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_VRISE,
+                                (unsigned long)&fsm->a_wait_vrise_tmout);
+        if (!a_wait_vrise_tmr)
+                return -ENOMEM;
+
+        a_wait_bcon_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_BCON,
+                                (unsigned long)&fsm->a_wait_bcon_tmout);
+        if (!a_wait_bcon_tmr)
+                return -ENOMEM;
+
+        a_aidl_bdis_tmr = otg_timer_initializer(&set_tmout, TA_AIDL_BDIS,
+                                (unsigned long)&fsm->a_aidl_bdis_tmout);
+        if (!a_aidl_bdis_tmr)
+                return -ENOMEM;
+
+        b_ase0_brst_tmr = otg_timer_initializer(&set_tmout, TB_ASE0_BRST,
+                                (unsigned long)&fsm->b_ase0_brst_tmout);
+        if (!b_ase0_brst_tmr)
+                return -ENOMEM;
+
+        b_se0_srp_tmr = otg_timer_initializer(&set_tmout, TB_SE0_SRP,
+                                (unsigned long)&fsm->b_se0_srp);
+        if (!b_se0_srp_tmr)
+                return -ENOMEM;
+
+        b_srp_fail_tmr = otg_timer_initializer(&set_tmout, TB_SRP_FAIL,
+                                (unsigned long)&fsm->b_srp_done);
+        if (!b_srp_fail_tmr)
+                return -ENOMEM;
+
+        a_wait_enum_tmr = otg_timer_initializer(&a_wait_enum, 10,
+                                (unsigned long)&fsm);
+        if (!a_wait_enum_tmr)
+                return -ENOMEM;
+
+        /* device driver used timers */
+        b_srp_wait_tmr = otg_timer_initializer(&b_srp_end, TB_SRP_WAIT, 0);
+        if (!b_srp_wait_tmr)
+                return -ENOMEM;
+
+        b_data_pulse_tmr = otg_timer_initializer(&b_data_pulse_end,
+                                TB_DATA_PLS, 0);
+        if (!b_data_pulse_tmr)
+                return -ENOMEM;
+
+        b_vbus_pulse_tmr = otg_timer_initializer(&b_vbus_pulse_end,
+                                TB_VBUS_PLS, 0);
+        if (!b_vbus_pulse_tmr)
+                return -ENOMEM;
+
+        return 0;
+}
+
+/* Uninitialize timers */
+void fsl_otg_uninit_timers(void)
+{
+        /* FSM used timers */
+        if (a_wait_vrise_tmr != NULL)
+                kfree(a_wait_vrise_tmr);
+        if (a_wait_bcon_tmr != NULL)
+                kfree(a_wait_bcon_tmr);
+        if (a_aidl_bdis_tmr != NULL)
+                kfree(a_aidl_bdis_tmr);
+        if (b_ase0_brst_tmr != NULL)
+                kfree(b_ase0_brst_tmr);
+        if (b_se0_srp_tmr != NULL)
+                kfree(b_se0_srp_tmr);
+        if (b_srp_fail_tmr != NULL)
+                kfree(b_srp_fail_tmr);
+        if (a_wait_enum_tmr != NULL)
+                kfree(a_wait_enum_tmr);
+
+        /* device driver used timers */
+        if (b_srp_wait_tmr != NULL)
+                kfree(b_srp_wait_tmr);
+        if (b_data_pulse_tmr != NULL)
+                kfree(b_data_pulse_tmr);
+        if (b_vbus_pulse_tmr != NULL)
+                kfree(b_vbus_pulse_tmr);
+}
+
+/* Add timer to timer list */
+void fsl_otg_add_timer(void *gtimer)
+{
+        struct fsl_otg_timer *timer = gtimer;
+        struct fsl_otg_timer *tmp_timer;
+
+        /*
+         * Check if the timer is already in the active list,
+         * if so update timer count
+         */
+        list_for_each_entry(tmp_timer, &active_timers, list)
+            if (tmp_timer == timer) {
+                timer->count = timer->expires;
+                return;
+        }
+        timer->count = timer->expires;
+        list_add_tail(&timer->list, &active_timers);
+}
+
+/* Remove timer from the timer list; clear timeout status */
+void fsl_otg_del_timer(void *gtimer)
+{
+        struct fsl_otg_timer *timer = gtimer;
+        struct fsl_otg_timer *tmp_timer, *del_tmp;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list)
+                if (tmp_timer == timer)
+                        list_del(&timer->list);
+}
+
+/*
+ * Reduce timer count by 1, and find timeout conditions.
+ * Called by fsl_otg 1ms timer interrupt
+ */
+int fsl_otg_tick_timer(void)
+{
+        struct fsl_otg_timer *tmp_timer, *del_tmp;
+        int expired = 0;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list) {
+                tmp_timer->count--;
+                /* check if timer expires */
+                if (!tmp_timer->count) {
+                        list_del(&tmp_timer->list);
+                        tmp_timer->function(tmp_timer->data);
+                        expired = 1;
+                }
+        }
+
+        return expired;
+}
+
+/* Reset controller, not reset the bus */
+void otg_reset_controller(void)
+{
+        u32 command;
+
+        command = fsl_readl(&usb_dr_regs->usbcmd);
+        command |= (1 << 1);
+        fsl_writel(command, &usb_dr_regs->usbcmd);
+        while (fsl_readl(&usb_dr_regs->usbcmd) & (1 << 1))
+                ;
+}
+
+/* Call suspend/resume routines in host driver */
+int fsl_otg_start_host(struct otg_fsm *fsm, int on)
+{
+        struct otg_transceiver *xceiv = fsm->transceiver;
+        struct device *dev;
+        struct fsl_otg *otg_dev = container_of(xceiv, struct fsl_otg, otg);
+        u32 retval = 0;
+
+        if (!xceiv->host)
+                return -ENODEV;
+        dev = xceiv->host->controller;
+
+        /*
+         * Update a_vbus_vld state as a_vbus_vld int is disabled
+         * in device mode
+         */
+        fsm->a_vbus_vld =
+                !!(fsl_readl(&usb_dr_regs->otgsc) & OTGSC_STS_A_VBUS_VALID);
+        if (on) {
+                /* start fsl usb host controller */
+                if (otg_dev->host_working)
+                        goto end;
+                else {
+                        otg_reset_controller();
+                        VDBG("host on......\n");
+                        if (dev->driver->pm && dev->driver->pm->resume) {
+                                retval = dev->driver->pm->resume(dev);
+                                if (fsm->id) {
+                                        /* default-b */
+                                        fsl_otg_drv_vbus(1);
+                                        /*
+                                         * Workaround: b_host can't driver
+                                         * vbus, but PP in PORTSC needs to
+                                         * be 1 for host to work.
+                                         * So we set drv_vbus bit in
+                                         * transceiver to 0 thru ULPI.
+                                         */
+                                        write_ulpi(0x0c, 0x20);
+                                }
+                        }
+
+                        otg_dev->host_working = 1;
+                }
+        } else {
+                /* stop fsl usb host controller */
+                if (!otg_dev->host_working)
+                        goto end;
+                else {
+                        VDBG("host off......\n");
+                        if (dev && dev->driver) {
+                                if (dev->driver->pm && dev->driver->pm->suspend)
+                                        retval = dev->driver->pm->suspend(dev);
+                                if (fsm->id)
+                                        /* default-b */
+                                        fsl_otg_drv_vbus(0);
+                        }
+                        otg_dev->host_working = 0;
+                }
+        }
+end:
+        return retval;
+}
+
+/*
+ * Call suspend and resume function in udc driver
+ * to stop and start udc driver.
+ */
+int fsl_otg_start_gadget(struct otg_fsm *fsm, int on)
+{
+        struct otg_transceiver *xceiv = fsm->transceiver;
+        struct device *dev;
+
+        if (!xceiv->gadget || !xceiv->gadget->dev.parent)
+                return -ENODEV;
+
+        VDBG("gadget %s\n", on ? "on" : "off");
+        dev = xceiv->gadget->dev.parent;
+
+        if (on) {
+                if (dev->driver->resume)
+                        dev->driver->resume(dev);
+        } else {
+                if (dev->driver->suspend)
+                        dev->driver->suspend(dev, otg_suspend_state);
+        }
+
+        return 0;
+}
+
+/*
+ * Called by initialization code of host driver.  Register host controller
+ * to the OTG.  Suspend host for OTG role detection.
+ */
+static int fsl_otg_set_host(struct otg_transceiver *otg_p, struct usb_bus *host)
+{
+        struct fsl_otg *otg_dev = container_of(otg_p, struct fsl_otg, otg);
+
+        if (!otg_p || otg_dev != fsl_otg_dev)
+                return -ENODEV;
+
+        otg_p->host = host;
+
+        otg_dev->fsm.a_bus_drop = 0;
+        otg_dev->fsm.a_bus_req = 1;
+
+        if (host) {
+                VDBG("host off......\n");
+
+                otg_p->host->otg_port = fsl_otg_initdata.otg_port;
+                otg_p->host->is_b_host = otg_dev->fsm.id;
+                /*
+                 * must leave time for khubd to finish its thing
+                 * before yanking the host driver out from under it,
+                 * so suspend the host after a short delay.
+                 */
+                otg_dev->host_working = 1;
+                schedule_delayed_work(&otg_dev->otg_event, 100);
+                return 0;
+        } else {
+                /* host driver going away */
+                if (!(fsl_readl(&otg_dev->dr_mem_map->otgsc) &
+                      OTGSC_STS_USB_ID)) {
+                        /* Mini-A cable connected */
+                        struct otg_fsm *fsm = &otg_dev->fsm;
+
+                        otg_p->state = OTG_STATE_UNDEFINED;
+                        fsm->protocol = PROTO_UNDEF;
+                }
+        }
+
+        otg_dev->host_working = 0;
+
+        otg_statemachine(&otg_dev->fsm);
+
+        return 0;
+}
+
+/* Called by initialization code of udc.  Register udc to OTG. */
+static int fsl_otg_set_peripheral(struct otg_transceiver *otg_p,
+                                  struct usb_gadget *gadget)
+{
+        struct fsl_otg *otg_dev = container_of(otg_p, struct fsl_otg, otg);
+
+        VDBG("otg_dev 0x%x\n", (int)otg_dev);
+        VDBG("fsl_otg_dev 0x%x\n", (int)fsl_otg_dev);
+
+        if (!otg_p || otg_dev != fsl_otg_dev)
+                return -ENODEV;
+
+        if (!gadget) {
+                if (!otg_dev->otg.default_a)
+                        otg_p->gadget->ops->vbus_draw(otg_p->gadget, 0);
+                usb_gadget_vbus_disconnect(otg_dev->otg.gadget);
+                otg_dev->otg.gadget = 0;
+                otg_dev->fsm.b_bus_req = 0;
+                otg_statemachine(&otg_dev->fsm);
+                return 0;
+        }
+
+        otg_p->gadget = gadget;
+        otg_p->gadget->is_a_peripheral = !otg_dev->fsm.id;
+
+        otg_dev->fsm.b_bus_req = 1;
+
+        /* start the gadget right away if the ID pin says Mini-B */
+        DBG("ID pin=%d\n", otg_dev->fsm.id);
+        if (otg_dev->fsm.id == 1) {
+                fsl_otg_start_host(&otg_dev->fsm, 0);
+                otg_drv_vbus(&otg_dev->fsm, 0);
+                fsl_otg_start_gadget(&otg_dev->fsm, 1);
+        }
+
+        return 0;
+}
+
+/* Set OTG port power, only for B-device */
+static int fsl_otg_set_power(struct otg_transceiver *otg_p, unsigned mA)
+{
+        if (!fsl_otg_dev)
+                return -ENODEV;
+        if (otg_p->state == OTG_STATE_B_PERIPHERAL)
+                pr_info("FSL OTG: Draw %d mA\n", mA);
+
+        return 0;
+}
+
+/*
+ * Delayed pin detect interrupt processing.
+ *
+ * When the Mini-A cable is disconnected from the board,
+ * the pin-detect interrupt happens before the disconnnect
+ * interrupts for the connected device(s).  In order to
+ * process the disconnect interrupt(s) prior to switching
+ * roles, the pin-detect interrupts are delayed, and handled
+ * by this routine.
+ */
+static void fsl_otg_event(struct work_struct *work)
+{
+        struct fsl_otg *og = container_of(work, struct fsl_otg, otg_event.work);
+        struct otg_fsm *fsm = &og->fsm;
+
+        if (fsm->id) {          /* switch to gadget */
+                fsl_otg_start_host(fsm, 0);
+                otg_drv_vbus(fsm, 0);
+                fsl_otg_start_gadget(fsm, 1);
+        }
+}
+
+/* B-device start SRP */
+static int fsl_otg_start_srp(struct otg_transceiver *otg_p)
+{
+        struct fsl_otg *otg_dev = container_of(otg_p, struct fsl_otg, otg);
+
+        if (!otg_p || otg_dev != fsl_otg_dev
+            || otg_p->state != OTG_STATE_B_IDLE)
+                return -ENODEV;
+
+        otg_dev->fsm.b_bus_req = 1;
+        otg_statemachine(&otg_dev->fsm);
+
+        return 0;
+}
+
+/* A_host suspend will call this function to start hnp */
+static int fsl_otg_start_hnp(struct otg_transceiver *otg_p)
+{
+        struct fsl_otg *otg_dev = container_of(otg_p, struct fsl_otg, otg);
+
+        if (!otg_p || otg_dev != fsl_otg_dev)
+                return -ENODEV;
+
+        DBG("start_hnp...n");
+
+        /* clear a_bus_req to enter a_suspend state */
+        otg_dev->fsm.a_bus_req = 0;
+        otg_statemachine(&otg_dev->fsm);
+
+        return 0;
+}
+
+/*
+ * Interrupt handler.  OTG/host/peripheral share the same int line.
+ * OTG driver clears OTGSC interrupts and leaves USB interrupts
+ * intact.  It needs to have knowledge of some USB interrupts
+ * such as port change.
+ */
+irqreturn_t fsl_otg_isr(int irq, void *dev_id)
+{
+        struct otg_fsm *fsm = &((struct fsl_otg *)dev_id)->fsm;
+        struct otg_transceiver *otg = &((struct fsl_otg *)dev_id)->otg;
+        u32 otg_int_src, otg_sc;
+
+        otg_sc = fsl_readl(&usb_dr_regs->otgsc);
+        otg_int_src = otg_sc & OTGSC_INTSTS_MASK & (otg_sc >> 8);
+
+        /* Only clear otg interrupts */
+        fsl_writel(otg_sc, &usb_dr_regs->otgsc);
+
+        /*FIXME: ID change not generate when init to 0 */
+        fsm->id = (otg_sc & OTGSC_STS_USB_ID) ? 1 : 0;
+        otg->default_a = (fsm->id == 0);
+
+        /* process OTG interrupts */
+        if (otg_int_src) {
+                if (otg_int_src & OTGSC_INTSTS_USB_ID) {
+                        fsm->id = (otg_sc & OTGSC_STS_USB_ID) ? 1 : 0;
+                        otg->default_a = (fsm->id == 0);
+                        /* clear conn information */
+                        if (fsm->id)
+                                fsm->b_conn = 0;
+                        else
+                                fsm->a_conn = 0;
+
+                        if (otg->host)
+                                otg->host->is_b_host = fsm->id;
+                        if (otg->gadget)
+                                otg->gadget->is_a_peripheral = !fsm->id;
+                        VDBG("ID int (ID is %d)\n", fsm->id);
+
+                        if (fsm->id) {  /* switch to gadget */
+                                schedule_delayed_work(
+                                        &((struct fsl_otg *)dev_id)->otg_event,
+                                        100);
+                        } else {        /* switch to host */
+                                cancel_delayed_work(&
+                                                    ((struct fsl_otg *)dev_id)->
+                                                    otg_event);
+                                fsl_otg_start_gadget(fsm, 0);
+                                otg_drv_vbus(fsm, 1);
+                                fsl_otg_start_host(fsm, 1);
+                        }
+                        return IRQ_HANDLED;
+                }
+        }
+        return IRQ_NONE;
+}
+
+static struct otg_fsm_ops fsl_otg_ops = {
+        .chrg_vbus = fsl_otg_chrg_vbus,
+        .drv_vbus = fsl_otg_drv_vbus,
+        .loc_conn = fsl_otg_loc_conn,
+        .loc_sof = fsl_otg_loc_sof,
+        .start_pulse = fsl_otg_start_pulse,
+
+        .add_timer = fsl_otg_add_timer,
+        .del_timer = fsl_otg_del_timer,
+
+        .start_host = fsl_otg_start_host,
+        .start_gadget = fsl_otg_start_gadget,
+};
+
+/* Initialize the global variable fsl_otg_dev and request IRQ for OTG */
+static int fsl_otg_conf(struct platform_device *pdev)
+{
+        struct fsl_otg *fsl_otg_tc;
+        int status;
+
+        if (fsl_otg_dev)
+                return 0;
+
+        /* allocate space to fsl otg device */
+        fsl_otg_tc = kzalloc(sizeof(struct fsl_otg), GFP_KERNEL);
+        if (!fsl_otg_tc)
+                return -ENOMEM;
+
+        INIT_DELAYED_WORK(&fsl_otg_tc->otg_event, fsl_otg_event);
+
+        INIT_LIST_HEAD(&active_timers);
+        status = fsl_otg_init_timers(&fsl_otg_tc->fsm);
+        if (status) {
+                pr_info("Couldn't init OTG timers\n");
+                goto err;
+        }
+        spin_lock_init(&fsl_otg_tc->fsm.lock);
+
+        /* Set OTG state machine operations */
+        fsl_otg_tc->fsm.ops = &fsl_otg_ops;
+
+        /* initialize the otg structure */
+        fsl_otg_tc->otg.label = DRIVER_DESC;
+        fsl_otg_tc->otg.set_host = fsl_otg_set_host;
+        fsl_otg_tc->otg.set_peripheral = fsl_otg_set_peripheral;
+        fsl_otg_tc->otg.set_power = fsl_otg_set_power;
+        fsl_otg_tc->otg.start_hnp = fsl_otg_start_hnp;
+        fsl_otg_tc->otg.start_srp = fsl_otg_start_srp;
+
+        fsl_otg_dev = fsl_otg_tc;
+
+        /* Store the otg transceiver */
+        status = otg_set_transceiver(&fsl_otg_tc->otg);
+        if (status) {
+                pr_warn(FSL_OTG_NAME ": unable to register OTG transceiver.\n");
+                goto err;
+        }
+
+        return 0;
+err:
+        fsl_otg_uninit_timers();
+        kfree(fsl_otg_tc);
+        return status;
+}
+
+/* OTG Initialization */
+int usb_otg_start(struct platform_device *pdev)
+{
+        struct fsl_otg *p_otg;
+        struct otg_transceiver *otg_trans = otg_get_transceiver();
+        struct otg_fsm *fsm;
+        int status;
+        struct resource *res;
+        u32 temp;
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+
+        p_otg = container_of(otg_trans, struct fsl_otg, otg);
+        fsm = &p_otg->fsm;
+
+        /* Initialize the state machine structure with default values */
+        SET_OTG_STATE(otg_trans, OTG_STATE_UNDEFINED);
+        fsm->transceiver = &p_otg->otg;
+
+        /* We don't require predefined MEM/IRQ resource index */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENXIO;
+
+        /* We don't request_mem_region here to enable resource sharing
+         * with host/device */
+
+        usb_dr_regs = ioremap(res->start, sizeof(struct usb_dr_mmap));
+        p_otg->dr_mem_map = (struct usb_dr_mmap *)usb_dr_regs;
+        pdata->regs = (void *)usb_dr_regs;
+
+        if (pdata->init && pdata->init(pdev) != 0)
+                return -EINVAL;
+
+        if (pdata->big_endian_mmio) {
+                _fsl_readl = _fsl_readl_be;
+                _fsl_writel = _fsl_writel_be;
+        } else {
+                _fsl_readl = _fsl_readl_le;
+                _fsl_writel = _fsl_writel_le;
+        }
+
+        /* request irq */
+        p_otg->irq = platform_get_irq(pdev, 0);
+        status = request_irq(p_otg->irq, fsl_otg_isr,
+                                IRQF_SHARED, driver_name, p_otg);
+        if (status) {
+                dev_dbg(p_otg->otg.dev, "can't get IRQ %d, error %d\n",
+                        p_otg->irq, status);
+                iounmap(p_otg->dr_mem_map);
+                kfree(p_otg);
+                return status;
+        }
+
+        /* stop the controller */
+        temp = fsl_readl(&p_otg->dr_mem_map->usbcmd);
+        temp &= ~USB_CMD_RUN_STOP;
+        fsl_writel(temp, &p_otg->dr_mem_map->usbcmd);
+
+        /* reset the controller */
+        temp = fsl_readl(&p_otg->dr_mem_map->usbcmd);
+        temp |= USB_CMD_CTRL_RESET;
+        fsl_writel(temp, &p_otg->dr_mem_map->usbcmd);
+
+        /* wait reset completed */
+        while (fsl_readl(&p_otg->dr_mem_map->usbcmd) & USB_CMD_CTRL_RESET)
+                ;
+
+        /* configure the VBUSHS as IDLE(both host and device) */
+        temp = USB_MODE_STREAM_DISABLE | (pdata->es ? USB_MODE_ES : 0);
+        fsl_writel(temp, &p_otg->dr_mem_map->usbmode);
+
+        /* configure PHY interface */
+        temp = fsl_readl(&p_otg->dr_mem_map->portsc);
+        temp &= ~(PORTSC_PHY_TYPE_SEL | PORTSC_PTW);
+        switch (pdata->phy_mode) {
+        case FSL_USB2_PHY_ULPI:
+                temp |= PORTSC_PTS_ULPI;
+                break;
+        case FSL_USB2_PHY_UTMI_WIDE:
+                temp |= PORTSC_PTW_16BIT;
+                /* fall through */
+        case FSL_USB2_PHY_UTMI:
+                temp |= PORTSC_PTS_UTMI;
+                /* fall through */
+        default:
+                break;
+        }
+        fsl_writel(temp, &p_otg->dr_mem_map->portsc);
+
+        if (pdata->have_sysif_regs) {
+                /* configure control enable IO output, big endian register */
+                temp = __raw_readl(&p_otg->dr_mem_map->control);
+                temp |= USB_CTRL_IOENB;
+                __raw_writel(temp, &p_otg->dr_mem_map->control);
+        }
+
+        /* disable all interrupt and clear all OTGSC status */
+        temp = fsl_readl(&p_otg->dr_mem_map->otgsc);
+        temp &= ~OTGSC_INTERRUPT_ENABLE_BITS_MASK;
+        temp |= OTGSC_INTERRUPT_STATUS_BITS_MASK | OTGSC_CTRL_VBUS_DISCHARGE;
+        fsl_writel(temp, &p_otg->dr_mem_map->otgsc);
+
+        /*
+         * The identification (id) input is FALSE when a Mini-A plug is inserted
+         * in the devices Mini-AB receptacle. Otherwise, this input is TRUE.
+         * Also: record initial state of ID pin
+         */
+        if (fsl_readl(&p_otg->dr_mem_map->otgsc) & OTGSC_STS_USB_ID) {
+                p_otg->otg.state = OTG_STATE_UNDEFINED;
+                p_otg->fsm.id = 1;
+        } else {
+                p_otg->otg.state = OTG_STATE_A_IDLE;
+                p_otg->fsm.id = 0;
+        }
+
+        DBG("initial ID pin=%d\n", p_otg->fsm.id);
+
+        /* enable OTG ID pin interrupt */
+        temp = fsl_readl(&p_otg->dr_mem_map->otgsc);
+        temp |= OTGSC_INTR_USB_ID_EN;
+        temp &= ~(OTGSC_CTRL_VBUS_DISCHARGE | OTGSC_INTR_1MS_TIMER_EN);
+        fsl_writel(temp, &p_otg->dr_mem_map->otgsc);
+
+        return 0;
+}
+
+/*
+ * state file in sysfs
+ */
+static int show_fsl_usb2_otg_state(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        struct otg_fsm *fsm = &fsl_otg_dev->fsm;
+        char *next = buf;
+        unsigned size = PAGE_SIZE;
+        unsigned long flags;
+        int t;
+
+        spin_lock_irqsave(&fsm->lock, flags);
+
+        /* basic driver infomation */
+        t = scnprintf(next, size,
+                        DRIVER_DESC "\n" "fsl_usb2_otg version: %s\n\n",
+                        DRIVER_VERSION);
+        size -= t;
+        next += t;
+
+        /* Registers */
+        t = scnprintf(next, size,
+                        "OTGSC:   0x%08x\n"
+                        "PORTSC:  0x%08x\n"
+                        "USBMODE: 0x%08x\n"
+                        "USBCMD:  0x%08x\n"
+                        "USBSTS:  0x%08x\n"
+                        "USBINTR: 0x%08x\n",
+                        fsl_readl(&usb_dr_regs->otgsc),
+                        fsl_readl(&usb_dr_regs->portsc),
+                        fsl_readl(&usb_dr_regs->usbmode),
+                        fsl_readl(&usb_dr_regs->usbcmd),
+                        fsl_readl(&usb_dr_regs->usbsts),
+                        fsl_readl(&usb_dr_regs->usbintr));
+        size -= t;
+        next += t;
+
+        /* State */
+        t = scnprintf(next, size,
+                      "OTG state: %s\n\n",
+                      otg_state_string(fsl_otg_dev->otg.state));
+        size -= t;
+        next += t;
+
+        /* State Machine Variables */
+        t = scnprintf(next, size,
+                        "a_bus_req: %d\n"
+                        "b_bus_req: %d\n"
+                        "a_bus_resume: %d\n"
+                        "a_bus_suspend: %d\n"
+                        "a_conn: %d\n"
+                        "a_sess_vld: %d\n"
+                        "a_srp_det: %d\n"
+                        "a_vbus_vld: %d\n"
+                        "b_bus_resume: %d\n"
+                        "b_bus_suspend: %d\n"
+                        "b_conn: %d\n"
+                        "b_se0_srp: %d\n"
+                        "b_sess_end: %d\n"
+                        "b_sess_vld: %d\n"
+                        "id: %d\n",
+                        fsm->a_bus_req,
+                        fsm->b_bus_req,
+                        fsm->a_bus_resume,
+                        fsm->a_bus_suspend,
+                        fsm->a_conn,
+                        fsm->a_sess_vld,
+                        fsm->a_srp_det,
+                        fsm->a_vbus_vld,
+                        fsm->b_bus_resume,
+                        fsm->b_bus_suspend,
+                        fsm->b_conn,
+                        fsm->b_se0_srp,
+                        fsm->b_sess_end,
+                        fsm->b_sess_vld,
+                        fsm->id);
+        size -= t;
+        next += t;
+
+        spin_unlock_irqrestore(&fsm->lock, flags);
+
+        return PAGE_SIZE - size;
+}
+
+static DEVICE_ATTR(fsl_usb2_otg_state, S_IRUGO, show_fsl_usb2_otg_state, NULL);
+
+
+/* Char driver interface to control some OTG input */
+
+/*
+ * Handle some ioctl command, such as get otg
+ * status and set host suspend
+ */
+static long fsl_otg_ioctl(struct file *file, unsigned int cmd,
+                          unsigned long arg)
+{
+        u32 retval = 0;
+
+        switch (cmd) {
+        case GET_OTG_STATUS:
+                retval = fsl_otg_dev->host_working;
+                break;
+
+        case SET_A_SUSPEND_REQ:
+                fsl_otg_dev->fsm.a_suspend_req = arg;
+                break;
+
+        case SET_A_BUS_DROP:
+                fsl_otg_dev->fsm.a_bus_drop = arg;
+                break;
+
+        case SET_A_BUS_REQ:
+                fsl_otg_dev->fsm.a_bus_req = arg;
+                break;
+
+        case SET_B_BUS_REQ:
+                fsl_otg_dev->fsm.b_bus_req = arg;
+                break;
+
+        default:
+                break;
+        }
+
+        otg_statemachine(&fsl_otg_dev->fsm);
+
+        return retval;
+}
+
+static int fsl_otg_open(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+
+static int fsl_otg_release(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+
+static const struct file_operations otg_fops = {
+        .owner = THIS_MODULE,
+        .llseek = NULL,
+        .read = NULL,
+        .write = NULL,
+        .unlocked_ioctl = fsl_otg_ioctl,
+        .open = fsl_otg_open,
+        .release = fsl_otg_release,
+};
+
+static int __devinit fsl_otg_probe(struct platform_device *pdev)
+{
+        int ret;
+
+        if (!pdev->dev.platform_data)
+                return -ENODEV;
+
+        /* configure the OTG */
+        ret = fsl_otg_conf(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "Couldn't configure OTG module\n");
+                return ret;
+        }
+
+        /* start OTG */
+        ret = usb_otg_start(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "Can't init FSL OTG device\n");
+                return ret;
+        }
+
+        ret = register_chrdev(FSL_OTG_MAJOR, FSL_OTG_NAME, &otg_fops);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to register FSL OTG device\n");
+                return ret;
+        }
+
+        ret = device_create_file(&pdev->dev, &dev_attr_fsl_usb2_otg_state);
+        if (ret)
+                dev_warn(&pdev->dev, "Can't register sysfs attribute\n");
+
+        return ret;
+}
+
+static int __devexit fsl_otg_remove(struct platform_device *pdev)
+{
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+
+        otg_set_transceiver(NULL);
+        free_irq(fsl_otg_dev->irq, fsl_otg_dev);
+
+        iounmap((void *)usb_dr_regs);
+
+        fsl_otg_uninit_timers();
+        kfree(fsl_otg_dev);
+
+        device_remove_file(&pdev->dev, &dev_attr_fsl_usb2_otg_state);
+
+        unregister_chrdev(FSL_OTG_MAJOR, FSL_OTG_NAME);
+
+        if (pdata->exit)
+                pdata->exit(pdev);
+
+        return 0;
+}
+
+struct platform_driver fsl_otg_driver = {
+        .probe = fsl_otg_probe,
+        .remove = __devexit_p(fsl_otg_remove),
+        .driver = {
+                .name = driver_name,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init fsl_usb_otg_init(void)
+{
+        pr_info(DRIVER_INFO "\n");
+        return platform_driver_register(&fsl_otg_driver);
+}
+module_init(fsl_usb_otg_init);
+
+static void __exit fsl_usb_otg_exit(void)
+{
+        platform_driver_unregister(&fsl_otg_driver);
+}
+module_exit(fsl_usb_otg_exit);
+
+MODULE_DESCRIPTION(DRIVER_INFO);
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/otg/fsl_otg.h b/drivers/usb/otg/fsl_otg.h
new file mode 100644
index 000000000000..3f8ef731aac9
--- /dev/null
+++ b/drivers/usb/otg/fsl_otg.h
@@ -0,0 +1,406 @@
+/* Copyright (C) 2007,2008 Freescale Semiconductor, 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, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the  GNU General Public License along
+ * with this program; if not, write  to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "otg_fsm.h"
+#include <linux/usb/otg.h>
+#include <linux/ioctl.h>
+
+/* USB Command Register Bit Masks */
+#define USB_CMD_RUN_STOP                (0x1<<0)
+#define USB_CMD_CTRL_RESET              (0x1<<1)
+#define USB_CMD_PERIODIC_SCHEDULE_EN    (0x1<<4)
+#define USB_CMD_ASYNC_SCHEDULE_EN       (0x1<<5)
+#define USB_CMD_INT_AA_DOORBELL         (0x1<<6)
+#define USB_CMD_ASP                     (0x3<<8)
+#define USB_CMD_ASYNC_SCH_PARK_EN       (0x1<<11)
+#define USB_CMD_SUTW                    (0x1<<13)
+#define USB_CMD_ATDTW                   (0x1<<14)
+#define USB_CMD_ITC                     (0xFF<<16)
+
+/* bit 15,3,2 are frame list size */
+#define USB_CMD_FRAME_SIZE_1024         (0x0<<15 | 0x0<<2)
+#define USB_CMD_FRAME_SIZE_512          (0x0<<15 | 0x1<<2)
+#define USB_CMD_FRAME_SIZE_256          (0x0<<15 | 0x2<<2)
+#define USB_CMD_FRAME_SIZE_128          (0x0<<15 | 0x3<<2)
+#define USB_CMD_FRAME_SIZE_64           (0x1<<15 | 0x0<<2)
+#define USB_CMD_FRAME_SIZE_32           (0x1<<15 | 0x1<<2)
+#define USB_CMD_FRAME_SIZE_16           (0x1<<15 | 0x2<<2)
+#define USB_CMD_FRAME_SIZE_8            (0x1<<15 | 0x3<<2)
+
+/* bit 9-8 are async schedule park mode count */
+#define USB_CMD_ASP_00                  (0x0<<8)
+#define USB_CMD_ASP_01                  (0x1<<8)
+#define USB_CMD_ASP_10                  (0x2<<8)
+#define USB_CMD_ASP_11                  (0x3<<8)
+#define USB_CMD_ASP_BIT_POS             (8)
+
+/* bit 23-16 are interrupt threshold control */
+#define USB_CMD_ITC_NO_THRESHOLD        (0x00<<16)
+#define USB_CMD_ITC_1_MICRO_FRM         (0x01<<16)
+#define USB_CMD_ITC_2_MICRO_FRM         (0x02<<16)
+#define USB_CMD_ITC_4_MICRO_FRM         (0x04<<16)
+#define USB_CMD_ITC_8_MICRO_FRM         (0x08<<16)
+#define USB_CMD_ITC_16_MICRO_FRM        (0x10<<16)
+#define USB_CMD_ITC_32_MICRO_FRM        (0x20<<16)
+#define USB_CMD_ITC_64_MICRO_FRM        (0x40<<16)
+#define USB_CMD_ITC_BIT_POS             (16)
+
+/* USB Status Register Bit Masks */
+#define USB_STS_INT                     (0x1<<0)
+#define USB_STS_ERR                     (0x1<<1)
+#define USB_STS_PORT_CHANGE             (0x1<<2)
+#define USB_STS_FRM_LST_ROLL            (0x1<<3)
+#define USB_STS_SYS_ERR                 (0x1<<4)
+#define USB_STS_IAA                     (0x1<<5)
+#define USB_STS_RESET_RECEIVED          (0x1<<6)
+#define USB_STS_SOF                     (0x1<<7)
+#define USB_STS_DCSUSPEND               (0x1<<8)
+#define USB_STS_HC_HALTED               (0x1<<12)
+#define USB_STS_RCL                     (0x1<<13)
+#define USB_STS_PERIODIC_SCHEDULE       (0x1<<14)
+#define USB_STS_ASYNC_SCHEDULE          (0x1<<15)
+
+/* USB Interrupt Enable Register Bit Masks */
+#define USB_INTR_INT_EN                 (0x1<<0)
+#define USB_INTR_ERR_INT_EN             (0x1<<1)
+#define USB_INTR_PC_DETECT_EN           (0x1<<2)
+#define USB_INTR_FRM_LST_ROLL_EN        (0x1<<3)
+#define USB_INTR_SYS_ERR_EN             (0x1<<4)
+#define USB_INTR_ASYN_ADV_EN            (0x1<<5)
+#define USB_INTR_RESET_EN               (0x1<<6)
+#define USB_INTR_SOF_EN                 (0x1<<7)
+#define USB_INTR_DEVICE_SUSPEND         (0x1<<8)
+
+/* Device Address bit masks */
+#define USB_DEVICE_ADDRESS_MASK         (0x7F<<25)
+#define USB_DEVICE_ADDRESS_BIT_POS      (25)
+/* PORTSC  Register Bit Masks,Only one PORT in OTG mode*/
+#define PORTSC_CURRENT_CONNECT_STATUS   (0x1<<0)
+#define PORTSC_CONNECT_STATUS_CHANGE    (0x1<<1)
+#define PORTSC_PORT_ENABLE              (0x1<<2)
+#define PORTSC_PORT_EN_DIS_CHANGE       (0x1<<3)
+#define PORTSC_OVER_CURRENT_ACT         (0x1<<4)
+#define PORTSC_OVER_CUURENT_CHG         (0x1<<5)
+#define PORTSC_PORT_FORCE_RESUME        (0x1<<6)
+#define PORTSC_PORT_SUSPEND             (0x1<<7)
+#define PORTSC_PORT_RESET               (0x1<<8)
+#define PORTSC_LINE_STATUS_BITS         (0x3<<10)
+#define PORTSC_PORT_POWER               (0x1<<12)
+#define PORTSC_PORT_INDICTOR_CTRL       (0x3<<14)
+#define PORTSC_PORT_TEST_CTRL           (0xF<<16)
+#define PORTSC_WAKE_ON_CONNECT_EN       (0x1<<20)
+#define PORTSC_WAKE_ON_CONNECT_DIS      (0x1<<21)
+#define PORTSC_WAKE_ON_OVER_CURRENT     (0x1<<22)
+#define PORTSC_PHY_LOW_POWER_SPD        (0x1<<23)
+#define PORTSC_PORT_FORCE_FULL_SPEED    (0x1<<24)
+#define PORTSC_PORT_SPEED_MASK          (0x3<<26)
+#define PORTSC_TRANSCEIVER_WIDTH        (0x1<<28)
+#define PORTSC_PHY_TYPE_SEL             (0x3<<30)
+/* bit 11-10 are line status */
+#define PORTSC_LINE_STATUS_SE0          (0x0<<10)
+#define PORTSC_LINE_STATUS_JSTATE       (0x1<<10)
+#define PORTSC_LINE_STATUS_KSTATE       (0x2<<10)
+#define PORTSC_LINE_STATUS_UNDEF        (0x3<<10)
+#define PORTSC_LINE_STATUS_BIT_POS      (10)
+
+/* bit 15-14 are port indicator control */
+#define PORTSC_PIC_OFF                  (0x0<<14)
+#define PORTSC_PIC_AMBER                (0x1<<14)
+#define PORTSC_PIC_GREEN                (0x2<<14)
+#define PORTSC_PIC_UNDEF                (0x3<<14)
+#define PORTSC_PIC_BIT_POS              (14)
+
+/* bit 19-16 are port test control */
+#define PORTSC_PTC_DISABLE              (0x0<<16)
+#define PORTSC_PTC_JSTATE               (0x1<<16)
+#define PORTSC_PTC_KSTATE               (0x2<<16)
+#define PORTSC_PTC_SEQNAK               (0x3<<16)
+#define PORTSC_PTC_PACKET               (0x4<<16)
+#define PORTSC_PTC_FORCE_EN             (0x5<<16)
+#define PORTSC_PTC_BIT_POS              (16)
+
+/* bit 27-26 are port speed */
+#define PORTSC_PORT_SPEED_FULL          (0x0<<26)
+#define PORTSC_PORT_SPEED_LOW           (0x1<<26)
+#define PORTSC_PORT_SPEED_HIGH          (0x2<<26)
+#define PORTSC_PORT_SPEED_UNDEF         (0x3<<26)
+#define PORTSC_SPEED_BIT_POS            (26)
+
+/* bit 28 is parallel transceiver width for UTMI interface */
+#define PORTSC_PTW                      (0x1<<28)
+#define PORTSC_PTW_8BIT                 (0x0<<28)
+#define PORTSC_PTW_16BIT                (0x1<<28)
+
+/* bit 31-30 are port transceiver select */
+#define PORTSC_PTS_UTMI                 (0x0<<30)
+#define PORTSC_PTS_ULPI                 (0x2<<30)
+#define PORTSC_PTS_FSLS_SERIAL          (0x3<<30)
+#define PORTSC_PTS_BIT_POS              (30)
+
+#define PORTSC_W1C_BITS                 \
+        (PORTSC_CONNECT_STATUS_CHANGE | \
+         PORTSC_PORT_EN_DIS_CHANGE    | \
+         PORTSC_OVER_CUURENT_CHG)
+
+/* OTG Status Control Register Bit Masks */
+#define OTGSC_CTRL_VBUS_DISCHARGE       (0x1<<0)
+#define OTGSC_CTRL_VBUS_CHARGE          (0x1<<1)
+#define OTGSC_CTRL_OTG_TERMINATION      (0x1<<3)
+#define OTGSC_CTRL_DATA_PULSING         (0x1<<4)
+#define OTGSC_CTRL_ID_PULL_EN           (0x1<<5)
+#define OTGSC_HA_DATA_PULSE             (0x1<<6)
+#define OTGSC_HA_BA                     (0x1<<7)
+#define OTGSC_STS_USB_ID                (0x1<<8)
+#define OTGSC_STS_A_VBUS_VALID          (0x1<<9)
+#define OTGSC_STS_A_SESSION_VALID       (0x1<<10)
+#define OTGSC_STS_B_SESSION_VALID       (0x1<<11)
+#define OTGSC_STS_B_SESSION_END         (0x1<<12)
+#define OTGSC_STS_1MS_TOGGLE            (0x1<<13)
+#define OTGSC_STS_DATA_PULSING          (0x1<<14)
+#define OTGSC_INTSTS_USB_ID             (0x1<<16)
+#define OTGSC_INTSTS_A_VBUS_VALID       (0x1<<17)
+#define OTGSC_INTSTS_A_SESSION_VALID    (0x1<<18)
+#define OTGSC_INTSTS_B_SESSION_VALID    (0x1<<19)
+#define OTGSC_INTSTS_B_SESSION_END      (0x1<<20)
+#define OTGSC_INTSTS_1MS                (0x1<<21)
+#define OTGSC_INTSTS_DATA_PULSING       (0x1<<22)
+#define OTGSC_INTR_USB_ID_EN            (0x1<<24)
+#define OTGSC_INTR_A_VBUS_VALID_EN      (0x1<<25)
+#define OTGSC_INTR_A_SESSION_VALID_EN   (0x1<<26)
+#define OTGSC_INTR_B_SESSION_VALID_EN   (0x1<<27)
+#define OTGSC_INTR_B_SESSION_END_EN     (0x1<<28)
+#define OTGSC_INTR_1MS_TIMER_EN         (0x1<<29)
+#define OTGSC_INTR_DATA_PULSING_EN      (0x1<<30)
+#define OTGSC_INTSTS_MASK               (0x00ff0000)
+
+/* USB MODE Register Bit Masks */
+#define  USB_MODE_CTRL_MODE_IDLE        (0x0<<0)
+#define  USB_MODE_CTRL_MODE_DEVICE      (0x2<<0)
+#define  USB_MODE_CTRL_MODE_HOST        (0x3<<0)
+#define  USB_MODE_CTRL_MODE_RSV         (0x1<<0)
+#define  USB_MODE_SETUP_LOCK_OFF        (0x1<<3)
+#define  USB_MODE_STREAM_DISABLE        (0x1<<4)
+#define  USB_MODE_ES                    (0x1<<2) /* Endian Select */
+
+/* control Register Bit Masks */
+#define  USB_CTRL_IOENB                 (0x1<<2)
+#define  USB_CTRL_ULPI_INT0EN           (0x1<<0)
+
+/* BCSR5 */
+#define BCSR5_INT_USB                   (0x02)
+
+/* USB module clk cfg */
+#define SCCR_OFFS                       (0xA08)
+#define SCCR_USB_CLK_DISABLE            (0x00000000)    /* USB clk disable */
+#define SCCR_USB_MPHCM_11               (0x00c00000)
+#define SCCR_USB_MPHCM_01               (0x00400000)
+#define SCCR_USB_MPHCM_10               (0x00800000)
+#define SCCR_USB_DRCM_11                (0x00300000)
+#define SCCR_USB_DRCM_01                (0x00100000)
+#define SCCR_USB_DRCM_10                (0x00200000)
+
+#define SICRL_OFFS                      (0x114)
+#define SICRL_USB0                      (0x40000000)
+#define SICRL_USB1                      (0x20000000)
+
+#define SICRH_OFFS                      (0x118)
+#define SICRH_USB_UTMI                  (0x00020000)
+
+/* OTG interrupt enable bit masks */
+#define  OTGSC_INTERRUPT_ENABLE_BITS_MASK  \
+        (OTGSC_INTR_USB_ID_EN            | \
+        OTGSC_INTR_1MS_TIMER_EN          | \
+        OTGSC_INTR_A_VBUS_VALID_EN       | \
+        OTGSC_INTR_A_SESSION_VALID_EN    | \
+        OTGSC_INTR_B_SESSION_VALID_EN    | \
+        OTGSC_INTR_B_SESSION_END_EN      | \
+        OTGSC_INTR_DATA_PULSING_EN)
+
+/* OTG interrupt status bit masks */
+#define  OTGSC_INTERRUPT_STATUS_BITS_MASK  \
+        (OTGSC_INTSTS_USB_ID          |    \
+        OTGSC_INTR_1MS_TIMER_EN       |    \
+        OTGSC_INTSTS_A_VBUS_VALID     |    \
+        OTGSC_INTSTS_A_SESSION_VALID  |    \
+        OTGSC_INTSTS_B_SESSION_VALID  |    \
+        OTGSC_INTSTS_B_SESSION_END    |    \
+        OTGSC_INTSTS_DATA_PULSING)
+
+/*
+ *  A-DEVICE timing  constants
+ */
+
+/* Wait for VBUS Rise  */
+#define TA_WAIT_VRISE   (100)   /* a_wait_vrise 100 ms, section: 6.6.5.1 */
+
+/* Wait for B-Connect */
+#define TA_WAIT_BCON    (10000)  /* a_wait_bcon > 1 sec, section: 6.6.5.2
+                                  * This is only used to get out of
+                                  * OTG_STATE_A_WAIT_BCON state if there was
+                                  * no connection for these many milliseconds
+                                  */
+
+/* A-Idle to B-Disconnect */
+/* It is necessary for this timer to be more than 750 ms because of a bug in OPT
+ * test 5.4 in which B OPT disconnects after 750 ms instead of 75ms as stated
+ * in the test description
+ */
+#define TA_AIDL_BDIS    (5000)  /* a_suspend minimum 200 ms, section: 6.6.5.3 */
+
+/* B-Idle to A-Disconnect */
+#define TA_BIDL_ADIS    (12)    /* 3 to 200 ms */
+
+/* B-device timing constants */
+
+
+/* Data-Line Pulse Time*/
+#define TB_DATA_PLS     (10)    /* b_srp_init,continue 5~10ms, section:5.3.3 */
+#define TB_DATA_PLS_MIN (5)     /* minimum 5 ms */
+#define TB_DATA_PLS_MAX (10)    /* maximum 10 ms */
+
+/* SRP Initiate Time  */
+#define TB_SRP_INIT     (100)   /* b_srp_init,maximum 100 ms, section:5.3.8 */
+
+/* SRP Fail Time  */
+#define TB_SRP_FAIL     (7000)  /* b_srp_init,Fail time 5~30s, section:6.8.2.2*/
+
+/* SRP result wait time */
+#define TB_SRP_WAIT     (60)
+
+/* VBus time */
+#define TB_VBUS_PLS     (30)    /* time to keep vbus pulsing asserted */
+
+/* Discharge time */
+/* This time should be less than 10ms. It varies from system to system. */
+#define TB_VBUS_DSCHRG  (8)
+
+/* A-SE0 to B-Reset  */
+#define TB_ASE0_BRST    (20)    /* b_wait_acon, mini 3.125 ms,section:6.8.2.4 */
+
+/* A bus suspend timer before we can switch to b_wait_aconn */
+#define TB_A_SUSPEND    (7)
+#define TB_BUS_RESUME   (12)
+
+/* SE0 Time Before SRP */
+#define TB_SE0_SRP      (2)     /* b_idle,minimum 2 ms, section:5.3.2 */
+
+#define SET_OTG_STATE(otg_ptr, newstate)        ((otg_ptr)->state = newstate)
+
+struct usb_dr_mmap {
+        /* Capability register */
+        u8 res1[256];
+        u16 caplength;          /* Capability Register Length */
+        u16 hciversion;         /* Host Controller Interface Version */
+        u32 hcsparams;          /* Host Controller Structual Parameters */
+        u32 hccparams;          /* Host Controller Capability Parameters */
+        u8 res2[20];
+        u32 dciversion;         /* Device Controller Interface Version */
+        u32 dccparams;          /* Device Controller Capability Parameters */
+        u8 res3[24];
+        /* Operation register */
+        u32 usbcmd;             /* USB Command Register */
+        u32 usbsts;             /* USB Status Register */
+        u32 usbintr;            /* USB Interrupt Enable Register */
+        u32 frindex;            /* Frame Index Register */
+        u8 res4[4];
+        u32 deviceaddr;         /* Device Address */
+        u32 endpointlistaddr;   /* Endpoint List Address Register */
+        u8 res5[4];
+        u32 burstsize;          /* Master Interface Data Burst Size Register */
+        u32 txttfilltuning;     /* Transmit FIFO Tuning Controls Register */
+        u8 res6[8];
+        u32 ulpiview;           /* ULPI register access */
+        u8 res7[12];
+        u32 configflag;         /* Configure Flag Register */
+        u32 portsc;             /* Port 1 Status and Control Register */
+        u8 res8[28];
+        u32 otgsc;              /* On-The-Go Status and Control */
+        u32 usbmode;            /* USB Mode Register */
+        u32 endptsetupstat;     /* Endpoint Setup Status Register */
+        u32 endpointprime;      /* Endpoint Initialization Register */
+        u32 endptflush;         /* Endpoint Flush Register */
+        u32 endptstatus;        /* Endpoint Status Register */
+        u32 endptcomplete;      /* Endpoint Complete Register */
+        u32 endptctrl[6];       /* Endpoint Control Registers */
+        u8 res9[552];
+        u32 snoop1;
+        u32 snoop2;
+        u32 age_cnt_thresh;     /* Age Count Threshold Register */
+        u32 pri_ctrl;           /* Priority Control Register */
+        u32 si_ctrl;            /* System Interface Control Register */
+        u8 res10[236];
+        u32 control;            /* General Purpose Control Register */
+};
+
+struct fsl_otg_timer {
+        unsigned long expires;  /* Number of count increase to timeout */
+        unsigned long count;    /* Tick counter */
+        void (*function)(unsigned long);        /* Timeout function */
+        unsigned long data;     /* Data passed to function */
+        struct list_head list;
+};
+
+inline struct fsl_otg_timer *otg_timer_initializer
+(void (*function)(unsigned long), unsigned long expires, unsigned long data)
+{
+        struct fsl_otg_timer *timer;
+
+        timer = kmalloc(sizeof(struct fsl_otg_timer), GFP_KERNEL);
+        if (!timer)
+                return NULL;
+        timer->function = function;
+        timer->expires = expires;
+        timer->data = data;
+        return timer;
+}
+
+struct fsl_otg {
+        struct otg_transceiver otg;
+        struct otg_fsm fsm;
+        struct usb_dr_mmap *dr_mem_map;
+        struct delayed_work otg_event;
+
+        /* used for usb host */
+        struct work_struct work_wq;
+        u8      host_working;
+
+        int irq;
+};
+
+struct fsl_otg_config {
+        u8 otg_port;
+};
+
+/* For SRP and HNP handle */
+#define FSL_OTG_MAJOR           240
+#define FSL_OTG_NAME            "fsl-usb2-otg"
+/* Command to OTG driver ioctl */
+#define OTG_IOCTL_MAGIC         FSL_OTG_MAJOR
+/* if otg work as host, it should return 1, otherwise return 0 */
+#define GET_OTG_STATUS          _IOR(OTG_IOCTL_MAGIC, 1, int)
+#define SET_A_SUSPEND_REQ       _IOW(OTG_IOCTL_MAGIC, 2, int)
+#define SET_A_BUS_DROP          _IOW(OTG_IOCTL_MAGIC, 3, int)
+#define SET_A_BUS_REQ           _IOW(OTG_IOCTL_MAGIC, 4, int)
+#define SET_B_BUS_REQ           _IOW(OTG_IOCTL_MAGIC, 5, int)
+#define GET_A_SUSPEND_REQ       _IOR(OTG_IOCTL_MAGIC, 6, int)
+#define GET_A_BUS_DROP          _IOR(OTG_IOCTL_MAGIC, 7, int)
+#define GET_A_BUS_REQ           _IOR(OTG_IOCTL_MAGIC, 8, int)
+#define GET_B_BUS_REQ           _IOR(OTG_IOCTL_MAGIC, 9, int)
+
+void fsl_otg_add_timer(void *timer);
+void fsl_otg_del_timer(void *timer);
+void fsl_otg_pulse_vbus(void);
diff --git a/drivers/usb/otg/gpio_vbus.c b/drivers/usb/otg/gpio_vbus.c
index 221c44444ec6..52733d9959b4 100644
--- a/drivers/usb/otg/gpio_vbus.c
+++ b/drivers/usb/otg/gpio_vbus.c
@@ -279,6 +279,13 @@ static int __init gpio_vbus_probe(struct platform_device *pdev)
         }
         INIT_WORK(&gpio_vbus->work, gpio_vbus_work);
 
+        gpio_vbus->vbus_draw = regulator_get(&pdev->dev, "vbus_draw");
+        if (IS_ERR(gpio_vbus->vbus_draw)) {
+                dev_dbg(&pdev->dev, "can't get vbus_draw regulator, err: %ld\n",
+                        PTR_ERR(gpio_vbus->vbus_draw));
+                gpio_vbus->vbus_draw = NULL;
+        }
+
         /* only active when a gadget is registered */
         err = otg_set_transceiver(&gpio_vbus->otg);
         if (err) {
@@ -287,13 +294,6 @@ static int __init gpio_vbus_probe(struct platform_device *pdev)
                 goto err_otg;
         }
 
-        gpio_vbus->vbus_draw = regulator_get(&pdev->dev, "vbus_draw");
-        if (IS_ERR(gpio_vbus->vbus_draw)) {
-                dev_dbg(&pdev->dev, "can't get vbus_draw regulator, err: %ld\n",
-                        PTR_ERR(gpio_vbus->vbus_draw));
-                gpio_vbus->vbus_draw = NULL;
-        }
-
         return 0;
 err_otg:
         free_irq(irq, &pdev->dev);
diff --git a/drivers/usb/otg/isp1301_omap.c b/drivers/usb/otg/isp1301_omap.c
index e25700f44b6f..8c282258e1bd 100644
--- a/drivers/usb/otg/isp1301_omap.c
+++ b/drivers/usb/otg/isp1301_omap.c
@@ -234,29 +234,9 @@ isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
 
 /*-------------------------------------------------------------------------*/
 
-static const char *state_string(enum usb_otg_state state)
-{
-        switch (state) {
-        case OTG_STATE_A_IDLE:          return "a_idle";
-        case OTG_STATE_A_WAIT_VRISE:    return "a_wait_vrise";
-        case OTG_STATE_A_WAIT_BCON:     return "a_wait_bcon";
-        case OTG_STATE_A_HOST:          return "a_host";
-        case OTG_STATE_A_SUSPEND:       return "a_suspend";
-        case OTG_STATE_A_PERIPHERAL:    return "a_peripheral";
-        case OTG_STATE_A_WAIT_VFALL:    return "a_wait_vfall";
-        case OTG_STATE_A_VBUS_ERR:      return "a_vbus_err";
-        case OTG_STATE_B_IDLE:          return "b_idle";
-        case OTG_STATE_B_SRP_INIT:      return "b_srp_init";
-        case OTG_STATE_B_PERIPHERAL:    return "b_peripheral";
-        case OTG_STATE_B_WAIT_ACON:     return "b_wait_acon";
-        case OTG_STATE_B_HOST:          return "b_host";
-        default:                        return "UNDEFINED";
-        }
-}
-
 static inline const char *state_name(struct isp1301 *isp)
 {
-        return state_string(isp->otg.state);
+        return otg_state_string(isp->otg.state);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -501,7 +481,7 @@ static void check_state(struct isp1301 *isp, const char *tag)
         if (isp->otg.state == state && !extra)
                 return;
         pr_debug("otg: %s FSM %s/%02x, %s, %06x\n", tag,
-                state_string(state), fsm, state_name(isp),
+                otg_state_string(state), fsm, state_name(isp),
                 omap_readl(OTG_CTRL));
 }
 
@@ -1095,7 +1075,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
 
         if (state != isp->otg.state)
                 pr_debug("  isp, %s -> %s\n",
-                                state_string(state), state_name(isp));
+                                otg_state_string(state), state_name(isp));
 
 #ifdef  CONFIG_USB_OTG
         /* update the OTG controller state to match the isp1301; may
diff --git a/drivers/usb/otg/langwell_otg.c b/drivers/usb/otg/langwell_otg.c
index e973ff19c55a..f08f784086f7 100644
--- a/drivers/usb/otg/langwell_otg.c
+++ b/drivers/usb/otg/langwell_otg.c
@@ -82,40 +82,6 @@ static struct pci_driver otg_pci_driver = {
         .resume =       langwell_otg_resume,
 };
 
-static const char *state_string(enum usb_otg_state state)
-{
-        switch (state) {
-        case OTG_STATE_A_IDLE:
-                return "a_idle";
-        case OTG_STATE_A_WAIT_VRISE:
-                return "a_wait_vrise";
-        case OTG_STATE_A_WAIT_BCON:
-                return "a_wait_bcon";
-        case OTG_STATE_A_HOST:
-                return "a_host";
-        case OTG_STATE_A_SUSPEND:
-                return "a_suspend";
-        case OTG_STATE_A_PERIPHERAL:
-                return "a_peripheral";
-        case OTG_STATE_A_WAIT_VFALL:
-                return "a_wait_vfall";
-        case OTG_STATE_A_VBUS_ERR:
-                return "a_vbus_err";
-        case OTG_STATE_B_IDLE:
-                return "b_idle";
-        case OTG_STATE_B_SRP_INIT:
-                return "b_srp_init";
-        case OTG_STATE_B_PERIPHERAL:
-                return "b_peripheral";
-        case OTG_STATE_B_WAIT_ACON:
-                return "b_wait_acon";
-        case OTG_STATE_B_HOST:
-                return "b_host";
-        default:
-                return "UNDEFINED";
-        }
-}
-
 /* HSM timers */
 static inline struct langwell_otg_timer *otg_timer_initializer
 (void (*function)(unsigned long), unsigned long expires, unsigned long data)
@@ -968,7 +934,7 @@ static void langwell_otg_work(struct work_struct *work)
         pdev = to_pci_dev(lnw->dev);
 
         dev_dbg(lnw->dev, "%s: old state = %s\n", __func__,
-                        state_string(iotg->otg.state));
+                        otg_state_string(iotg->otg.state));
 
         switch (iotg->otg.state) {
         case OTG_STATE_UNDEFINED:
@@ -1703,7 +1669,7 @@ static void langwell_otg_work(struct work_struct *work)
         }
 
         dev_dbg(lnw->dev, "%s: new state = %s\n", __func__,
-                        state_string(iotg->otg.state));
+                        otg_state_string(iotg->otg.state));
 }
 
 static ssize_t
@@ -1789,7 +1755,7 @@ show_hsm(struct device *_dev, struct device_attribute *attr, char *buf)
                 "b_bus_req = \t%d\n"
                 "b_bus_suspend_tmout = \t%d\n"
                 "b_bus_suspend_vld = \t%d\n",
-                state_string(iotg->otg.state),
+                otg_state_string(iotg->otg.state),
                 iotg->hsm.a_bus_resume,
                 iotg->hsm.a_bus_suspend,
                 iotg->hsm.a_conn,
diff --git a/drivers/usb/otg/msm_otg.c b/drivers/usb/otg/msm_otg.c
index 296598628b85..1cdda6c05238 100644
--- a/drivers/usb/otg/msm_otg.c
+++ b/drivers/usb/otg/msm_otg.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2010, Code Aurora Forum. All rights reserved.
+/* Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
@@ -38,6 +38,7 @@
 #include <linux/usb/hcd.h>
 #include <linux/usb/msm_hsusb.h>
 #include <linux/usb/msm_hsusb_hw.h>
+#include <linux/regulator/consumer.h>
 
 #include <mach/clk.h>
 
@@ -45,6 +46,197 @@
 #define DRIVER_NAME     "msm_otg"
 
 #define ULPI_IO_TIMEOUT_USEC    (10 * 1000)
+
+#define USB_PHY_3P3_VOL_MIN     3050000 /* uV */
+#define USB_PHY_3P3_VOL_MAX     3300000 /* uV */
+#define USB_PHY_3P3_HPM_LOAD    50000   /* uA */
+#define USB_PHY_3P3_LPM_LOAD    4000    /* uA */
+
+#define USB_PHY_1P8_VOL_MIN     1800000 /* uV */
+#define USB_PHY_1P8_VOL_MAX     1800000 /* uV */
+#define USB_PHY_1P8_HPM_LOAD    50000   /* uA */
+#define USB_PHY_1P8_LPM_LOAD    4000    /* uA */
+
+#define USB_PHY_VDD_DIG_VOL_MIN 1000000 /* uV */
+#define USB_PHY_VDD_DIG_VOL_MAX 1320000 /* uV */
+
+static struct regulator *hsusb_3p3;
+static struct regulator *hsusb_1p8;
+static struct regulator *hsusb_vddcx;
+
+static int msm_hsusb_init_vddcx(struct msm_otg *motg, int init)
+{
+        int ret = 0;
+
+        if (init) {
+                hsusb_vddcx = regulator_get(motg->otg.dev, "HSUSB_VDDCX");
+                if (IS_ERR(hsusb_vddcx)) {
+                        dev_err(motg->otg.dev, "unable to get hsusb vddcx\n");
+                        return PTR_ERR(hsusb_vddcx);
+                }
+
+                ret = regulator_set_voltage(hsusb_vddcx,
+                                USB_PHY_VDD_DIG_VOL_MIN,
+                                USB_PHY_VDD_DIG_VOL_MAX);
+                if (ret) {
+                        dev_err(motg->otg.dev, "unable to set the voltage "
+                                        "for hsusb vddcx\n");
+                        regulator_put(hsusb_vddcx);
+                        return ret;
+                }
+
+                ret = regulator_enable(hsusb_vddcx);
+                if (ret) {
+                        dev_err(motg->otg.dev, "unable to enable hsusb vddcx\n");
+                        regulator_put(hsusb_vddcx);
+                }
+        } else {
+                ret = regulator_set_voltage(hsusb_vddcx, 0,
+                        USB_PHY_VDD_DIG_VOL_MIN);
+                if (ret) {
+                        dev_err(motg->otg.dev, "unable to set the voltage "
+                                        "for hsusb vddcx\n");
+                        return ret;
+                }
+                ret = regulator_disable(hsusb_vddcx);
+                if (ret)
+                        dev_err(motg->otg.dev, "unable to disable hsusb vddcx\n");
+
+                regulator_put(hsusb_vddcx);
+        }
+
+        return ret;
+}
+
+static int msm_hsusb_ldo_init(struct msm_otg *motg, int init)
+{
+        int rc = 0;
+
+        if (init) {
+                hsusb_3p3 = regulator_get(motg->otg.dev, "HSUSB_3p3");
+                if (IS_ERR(hsusb_3p3)) {
+                        dev_err(motg->otg.dev, "unable to get hsusb 3p3\n");
+                        return PTR_ERR(hsusb_3p3);
+                }
+
+                rc = regulator_set_voltage(hsusb_3p3, USB_PHY_3P3_VOL_MIN,
+                                USB_PHY_3P3_VOL_MAX);
+                if (rc) {
+                        dev_err(motg->otg.dev, "unable to set voltage level "
+                                        "for hsusb 3p3\n");
+                        goto put_3p3;
+                }
+                rc = regulator_enable(hsusb_3p3);
+                if (rc) {
+                        dev_err(motg->otg.dev, "unable to enable the hsusb 3p3\n");
+                        goto put_3p3;
+                }
+                hsusb_1p8 = regulator_get(motg->otg.dev, "HSUSB_1p8");
+                if (IS_ERR(hsusb_1p8)) {
+                        dev_err(motg->otg.dev, "unable to get hsusb 1p8\n");
+                        rc = PTR_ERR(hsusb_1p8);
+                        goto disable_3p3;
+                }
+                rc = regulator_set_voltage(hsusb_1p8, USB_PHY_1P8_VOL_MIN,
+                                USB_PHY_1P8_VOL_MAX);
+                if (rc) {
+                        dev_err(motg->otg.dev, "unable to set voltage level "
+                                        "for hsusb 1p8\n");
+                        goto put_1p8;
+                }
+                rc = regulator_enable(hsusb_1p8);
+                if (rc) {
+                        dev_err(motg->otg.dev, "unable to enable the hsusb 1p8\n");
+                        goto put_1p8;
+                }
+
+                return 0;
+        }
+
+        regulator_disable(hsusb_1p8);
+put_1p8:
+        regulator_put(hsusb_1p8);
+disable_3p3:
+        regulator_disable(hsusb_3p3);
+put_3p3:
+        regulator_put(hsusb_3p3);
+        return rc;
+}
+
+#ifdef CONFIG_PM_SLEEP
+#define USB_PHY_SUSP_DIG_VOL  500000
+static int msm_hsusb_config_vddcx(int high)
+{
+        int max_vol = USB_PHY_VDD_DIG_VOL_MAX;
+        int min_vol;
+        int ret;
+
+        if (high)
+                min_vol = USB_PHY_VDD_DIG_VOL_MIN;
+        else
+                min_vol = USB_PHY_SUSP_DIG_VOL;
+
+        ret = regulator_set_voltage(hsusb_vddcx, min_vol, max_vol);
+        if (ret) {
+                pr_err("%s: unable to set the voltage for regulator "
+                        "HSUSB_VDDCX\n", __func__);
+                return ret;
+        }
+
+        pr_debug("%s: min_vol:%d max_vol:%d\n", __func__, min_vol, max_vol);
+
+        return ret;
+}
+#endif
+
+static int msm_hsusb_ldo_set_mode(int on)
+{
+        int ret = 0;
+
+        if (!hsusb_1p8 || IS_ERR(hsusb_1p8)) {
+                pr_err("%s: HSUSB_1p8 is not initialized\n", __func__);
+                return -ENODEV;
+        }
+
+        if (!hsusb_3p3 || IS_ERR(hsusb_3p3)) {
+                pr_err("%s: HSUSB_3p3 is not initialized\n", __func__);
+                return -ENODEV;
+        }
+
+        if (on) {
+                ret = regulator_set_optimum_mode(hsusb_1p8,
+                                USB_PHY_1P8_HPM_LOAD);
+                if (ret < 0) {
+                        pr_err("%s: Unable to set HPM of the regulator "
+                                "HSUSB_1p8\n", __func__);
+                        return ret;
+                }
+                ret = regulator_set_optimum_mode(hsusb_3p3,
+                                USB_PHY_3P3_HPM_LOAD);
+                if (ret < 0) {
+                        pr_err("%s: Unable to set HPM of the regulator "
+                                "HSUSB_3p3\n", __func__);
+                        regulator_set_optimum_mode(hsusb_1p8,
+                                USB_PHY_1P8_LPM_LOAD);
+                        return ret;
+                }
+        } else {
+                ret = regulator_set_optimum_mode(hsusb_1p8,
+                                USB_PHY_1P8_LPM_LOAD);
+                if (ret < 0)
+                        pr_err("%s: Unable to set LPM of the regulator "
+                                "HSUSB_1p8\n", __func__);
+                ret = regulator_set_optimum_mode(hsusb_3p3,
+                                USB_PHY_3P3_LPM_LOAD);
+                if (ret < 0)
+                        pr_err("%s: Unable to set LPM of the regulator "
+                                "HSUSB_3p3\n", __func__);
+        }
+
+        pr_debug("reg (%s)\n", on ? "HPM" : "LPM");
+        return ret < 0 ? ret : 0;
+}
+
 static int ulpi_read(struct otg_transceiver *otg, u32 reg)
 {
         struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
@@ -268,27 +460,28 @@ static int msm_otg_suspend(struct msm_otg *motg)
 
         disable_irq(motg->irq);
         /*
+         * Chipidea 45-nm PHY suspend sequence:
+         *
          * Interrupt Latch Register auto-clear feature is not present
          * in all PHY versions. Latch register is clear on read type.
          * Clear latch register to avoid spurious wakeup from
          * low power mode (LPM).
-         */
-        ulpi_read(otg, 0x14);
-
-        /*
+         *
          * PHY comparators are disabled when PHY enters into low power
          * mode (LPM). Keep PHY comparators ON in LPM only when we expect
          * VBUS/Id notifications from USB PHY. Otherwise turn off USB
          * PHY comparators. This save significant amount of power.
-         */
-        if (pdata->otg_control == OTG_PHY_CONTROL)
-                ulpi_write(otg, 0x01, 0x30);
-
-        /*
+         *
          * PLL is not turned off when PHY enters into low power mode (LPM).
          * Disable PLL for maximum power savings.
          */
-        ulpi_write(otg, 0x08, 0x09);
+
+        if (motg->pdata->phy_type == CI_45NM_INTEGRATED_PHY) {
+                ulpi_read(otg, 0x14);
+                if (pdata->otg_control == OTG_PHY_CONTROL)
+                        ulpi_write(otg, 0x01, 0x30);
+                ulpi_write(otg, 0x08, 0x09);
+        }
 
         /*
          * PHY may take some time or even fail to enter into low power
@@ -319,11 +512,24 @@ static int msm_otg_suspend(struct msm_otg *motg)
          */
         writel(readl(USB_USBCMD) | ASYNC_INTR_CTRL | ULPI_STP_CTRL, USB_USBCMD);
 
+        if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
+                        motg->pdata->otg_control == OTG_PMIC_CONTROL)
+                writel(readl(USB_PHY_CTRL) | PHY_RETEN, USB_PHY_CTRL);
+
         clk_disable(motg->pclk);
         clk_disable(motg->clk);
         if (motg->core_clk)
                 clk_disable(motg->core_clk);
 
+        if (!IS_ERR(motg->pclk_src))
+                clk_disable(motg->pclk_src);
+
+        if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
+                        motg->pdata->otg_control == OTG_PMIC_CONTROL) {
+                msm_hsusb_ldo_set_mode(0);
+                msm_hsusb_config_vddcx(0);
+        }
+
         if (device_may_wakeup(otg->dev))
                 enable_irq_wake(motg->irq);
         if (bus)
@@ -347,11 +553,21 @@ static int msm_otg_resume(struct msm_otg *motg)
         if (!atomic_read(&motg->in_lpm))
                 return 0;
 
+        if (!IS_ERR(motg->pclk_src))
+                clk_enable(motg->pclk_src);
+
         clk_enable(motg->pclk);
         clk_enable(motg->clk);
         if (motg->core_clk)
                 clk_enable(motg->core_clk);
 
+        if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
+                        motg->pdata->otg_control == OTG_PMIC_CONTROL) {
+                msm_hsusb_ldo_set_mode(1);
+                msm_hsusb_config_vddcx(1);
+                writel(readl(USB_PHY_CTRL) & ~PHY_RETEN, USB_PHY_CTRL);
+        }
+
         temp = readl(USB_USBCMD);
         temp &= ~ASYNC_INTR_CTRL;
         temp &= ~ULPI_STP_CTRL;
@@ -389,20 +605,47 @@ skip_phy_resume:
         if (bus)
                 set_bit(HCD_FLAG_HW_ACCESSIBLE, &(bus_to_hcd(bus))->flags);
 
+        atomic_set(&motg->in_lpm, 0);
+
         if (motg->async_int) {
                 motg->async_int = 0;
                 pm_runtime_put(otg->dev);
                 enable_irq(motg->irq);
         }
 
-        atomic_set(&motg->in_lpm, 0);
-
         dev_info(otg->dev, "USB exited from low power mode\n");
 
         return 0;
 }
 #endif
 
+static void msm_otg_notify_charger(struct msm_otg *motg, unsigned mA)
+{
+        if (motg->cur_power == mA)
+                return;
+
+        /* TODO: Notify PMIC about available current */
+        dev_info(motg->otg.dev, "Avail curr from USB = %u\n", mA);
+        motg->cur_power = mA;
+}
+
+static int msm_otg_set_power(struct otg_transceiver *otg, unsigned mA)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+
+        /*
+         * Gadget driver uses set_power method to notify about the
+         * available current based on suspend/configured states.
+         *
+         * IDEV_CHG can be drawn irrespective of suspend/un-configured
+         * states when CDP/ACA is connected.
+         */
+        if (motg->chg_type == USB_SDP_CHARGER)
+                msm_otg_notify_charger(motg, mA);
+
+        return 0;
+}
+
 static void msm_otg_start_host(struct otg_transceiver *otg, int on)
 {
         struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
@@ -557,6 +800,306 @@ static int msm_otg_set_peripheral(struct otg_transceiver *otg,
         return 0;
 }
 
+static bool msm_chg_check_secondary_det(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+        bool ret = false;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                ret = chg_det & (1 << 4);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x87);
+                ret = chg_det & 1;
+                break;
+        default:
+                break;
+        }
+        return ret;
+}
+
+static void msm_chg_enable_secondary_det(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* Turn off charger block */
+                chg_det |= ~(1 << 1);
+                ulpi_write(otg, chg_det, 0x34);
+                udelay(20);
+                /* control chg block via ULPI */
+                chg_det &= ~(1 << 3);
+                ulpi_write(otg, chg_det, 0x34);
+                /* put it in host mode for enabling D- source */
+                chg_det &= ~(1 << 2);
+                ulpi_write(otg, chg_det, 0x34);
+                /* Turn on chg detect block */
+                chg_det &= ~(1 << 1);
+                ulpi_write(otg, chg_det, 0x34);
+                udelay(20);
+                /* enable chg detection */
+                chg_det &= ~(1 << 0);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /*
+                 * Configure DM as current source, DP as current sink
+                 * and enable battery charging comparators.
+                 */
+                ulpi_write(otg, 0x8, 0x85);
+                ulpi_write(otg, 0x2, 0x85);
+                ulpi_write(otg, 0x1, 0x85);
+                break;
+        default:
+                break;
+        }
+}
+
+static bool msm_chg_check_primary_det(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+        bool ret = false;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                ret = chg_det & (1 << 4);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x87);
+                ret = chg_det & 1;
+                break;
+        default:
+                break;
+        }
+        return ret;
+}
+
+static void msm_chg_enable_primary_det(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* enable chg detection */
+                chg_det &= ~(1 << 0);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /*
+                 * Configure DP as current source, DM as current sink
+                 * and enable battery charging comparators.
+                 */
+                ulpi_write(otg, 0x2, 0x85);
+                ulpi_write(otg, 0x1, 0x85);
+                break;
+        default:
+                break;
+        }
+}
+
+static bool msm_chg_check_dcd(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 line_state;
+        bool ret = false;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                line_state = ulpi_read(otg, 0x15);
+                ret = !(line_state & 1);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                line_state = ulpi_read(otg, 0x87);
+                ret = line_state & 2;
+                break;
+        default:
+                break;
+        }
+        return ret;
+}
+
+static void msm_chg_disable_dcd(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                chg_det &= ~(1 << 5);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                ulpi_write(otg, 0x10, 0x86);
+                break;
+        default:
+                break;
+        }
+}
+
+static void msm_chg_enable_dcd(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* Turn on D+ current source */
+                chg_det |= (1 << 5);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /* Data contact detection enable */
+                ulpi_write(otg, 0x10, 0x85);
+                break;
+        default:
+                break;
+        }
+}
+
+static void msm_chg_block_on(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 func_ctrl, chg_det;
+
+        /* put the controller in non-driving mode */
+        func_ctrl = ulpi_read(otg, ULPI_FUNC_CTRL);
+        func_ctrl &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
+        func_ctrl |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
+        ulpi_write(otg, func_ctrl, ULPI_FUNC_CTRL);
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* control chg block via ULPI */
+                chg_det &= ~(1 << 3);
+                ulpi_write(otg, chg_det, 0x34);
+                /* Turn on chg detect block */
+                chg_det &= ~(1 << 1);
+                ulpi_write(otg, chg_det, 0x34);
+                udelay(20);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /* Clear charger detecting control bits */
+                ulpi_write(otg, 0x3F, 0x86);
+                /* Clear alt interrupt latch and enable bits */
+                ulpi_write(otg, 0x1F, 0x92);
+                ulpi_write(otg, 0x1F, 0x95);
+                udelay(100);
+                break;
+        default:
+                break;
+        }
+}
+
+static void msm_chg_block_off(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        u32 func_ctrl, chg_det;
+
+        switch (motg->pdata->phy_type) {
+        case CI_45NM_INTEGRATED_PHY:
+                chg_det = ulpi_read(otg, 0x34);
+                /* Turn off charger block */
+                chg_det |= ~(1 << 1);
+                ulpi_write(otg, chg_det, 0x34);
+                break;
+        case SNPS_28NM_INTEGRATED_PHY:
+                /* Clear charger detecting control bits */
+                ulpi_write(otg, 0x3F, 0x86);
+                /* Clear alt interrupt latch and enable bits */
+                ulpi_write(otg, 0x1F, 0x92);
+                ulpi_write(otg, 0x1F, 0x95);
+                break;
+        default:
+                break;
+        }
+
+        /* put the controller in normal mode */
+        func_ctrl = ulpi_read(otg, ULPI_FUNC_CTRL);
+        func_ctrl &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
+        func_ctrl |= ULPI_FUNC_CTRL_OPMODE_NORMAL;
+        ulpi_write(otg, func_ctrl, ULPI_FUNC_CTRL);
+}
+
+#define MSM_CHG_DCD_POLL_TIME           (100 * HZ/1000) /* 100 msec */
+#define MSM_CHG_DCD_MAX_RETRIES         6 /* Tdcd_tmout = 6 * 100 msec */
+#define MSM_CHG_PRIMARY_DET_TIME        (40 * HZ/1000) /* TVDPSRC_ON */
+#define MSM_CHG_SECONDARY_DET_TIME      (40 * HZ/1000) /* TVDMSRC_ON */
+static void msm_chg_detect_work(struct work_struct *w)
+{
+        struct msm_otg *motg = container_of(w, struct msm_otg, chg_work.work);
+        struct otg_transceiver *otg = &motg->otg;
+        bool is_dcd, tmout, vout;
+        unsigned long delay;
+
+        dev_dbg(otg->dev, "chg detection work\n");
+        switch (motg->chg_state) {
+        case USB_CHG_STATE_UNDEFINED:
+                pm_runtime_get_sync(otg->dev);
+                msm_chg_block_on(motg);
+                msm_chg_enable_dcd(motg);
+                motg->chg_state = USB_CHG_STATE_WAIT_FOR_DCD;
+                motg->dcd_retries = 0;
+                delay = MSM_CHG_DCD_POLL_TIME;
+                break;
+        case USB_CHG_STATE_WAIT_FOR_DCD:
+                is_dcd = msm_chg_check_dcd(motg);
+                tmout = ++motg->dcd_retries == MSM_CHG_DCD_MAX_RETRIES;
+                if (is_dcd || tmout) {
+                        msm_chg_disable_dcd(motg);
+                        msm_chg_enable_primary_det(motg);
+                        delay = MSM_CHG_PRIMARY_DET_TIME;
+                        motg->chg_state = USB_CHG_STATE_DCD_DONE;
+                } else {
+                        delay = MSM_CHG_DCD_POLL_TIME;
+                }
+                break;
+        case USB_CHG_STATE_DCD_DONE:
+                vout = msm_chg_check_primary_det(motg);
+                if (vout) {
+                        msm_chg_enable_secondary_det(motg);
+                        delay = MSM_CHG_SECONDARY_DET_TIME;
+                        motg->chg_state = USB_CHG_STATE_PRIMARY_DONE;
+                } else {
+                        motg->chg_type = USB_SDP_CHARGER;
+                        motg->chg_state = USB_CHG_STATE_DETECTED;
+                        delay = 0;
+                }
+                break;
+        case USB_CHG_STATE_PRIMARY_DONE:
+                vout = msm_chg_check_secondary_det(motg);
+                if (vout)
+                        motg->chg_type = USB_DCP_CHARGER;
+                else
+                        motg->chg_type = USB_CDP_CHARGER;
+                motg->chg_state = USB_CHG_STATE_SECONDARY_DONE;
+                /* fall through */
+        case USB_CHG_STATE_SECONDARY_DONE:
+                motg->chg_state = USB_CHG_STATE_DETECTED;
+        case USB_CHG_STATE_DETECTED:
+                msm_chg_block_off(motg);
+                dev_dbg(otg->dev, "charger = %d\n", motg->chg_type);
+                schedule_work(&motg->sm_work);
+                return;
+        default:
+                return;
+        }
+
+        schedule_delayed_work(&motg->chg_work, delay);
+}
+
 /*
  * We support OTG, Peripheral only and Host only configurations. In case
  * of OTG, mode switch (host-->peripheral/peripheral-->host) can happen
@@ -627,9 +1170,48 @@ static void msm_otg_sm_work(struct work_struct *w)
                         writel(readl(USB_OTGSC) & ~OTGSC_BSVIE, USB_OTGSC);
                         msm_otg_start_host(otg, 1);
                         otg->state = OTG_STATE_A_HOST;
-                } else if (test_bit(B_SESS_VLD, &motg->inputs) && otg->gadget) {
-                        msm_otg_start_peripheral(otg, 1);
-                        otg->state = OTG_STATE_B_PERIPHERAL;
+                } else if (test_bit(B_SESS_VLD, &motg->inputs)) {
+                        switch (motg->chg_state) {
+                        case USB_CHG_STATE_UNDEFINED:
+                                msm_chg_detect_work(&motg->chg_work.work);
+                                break;
+                        case USB_CHG_STATE_DETECTED:
+                                switch (motg->chg_type) {
+                                case USB_DCP_CHARGER:
+                                        msm_otg_notify_charger(motg,
+                                                        IDEV_CHG_MAX);
+                                        break;
+                                case USB_CDP_CHARGER:
+                                        msm_otg_notify_charger(motg,
+                                                        IDEV_CHG_MAX);
+                                        msm_otg_start_peripheral(otg, 1);
+                                        otg->state = OTG_STATE_B_PERIPHERAL;
+                                        break;
+                                case USB_SDP_CHARGER:
+                                        msm_otg_notify_charger(motg, IUNIT);
+                                        msm_otg_start_peripheral(otg, 1);
+                                        otg->state = OTG_STATE_B_PERIPHERAL;
+                                        break;
+                                default:
+                                        break;
+                                }
+                                break;
+                        default:
+                                break;
+                        }
+                } else {
+                        /*
+                         * If charger detection work is pending, decrement
+                         * the pm usage counter to balance with the one that
+                         * is incremented in charger detection work.
+                         */
+                        if (cancel_delayed_work_sync(&motg->chg_work)) {
+                                pm_runtime_put_sync(otg->dev);
+                                msm_otg_reset(otg);
+                        }
+                        msm_otg_notify_charger(motg, 0);
+                        motg->chg_state = USB_CHG_STATE_UNDEFINED;
+                        motg->chg_type = USB_INVALID_CHARGER;
                 }
                 pm_runtime_put_sync(otg->dev);
                 break;
@@ -637,7 +1219,10 @@ static void msm_otg_sm_work(struct work_struct *w)
                 dev_dbg(otg->dev, "OTG_STATE_B_PERIPHERAL state\n");
                 if (!test_bit(B_SESS_VLD, &motg->inputs) ||
                                 !test_bit(ID, &motg->inputs)) {
+                        msm_otg_notify_charger(motg, 0);
                         msm_otg_start_peripheral(otg, 0);
+                        motg->chg_state = USB_CHG_STATE_UNDEFINED;
+                        motg->chg_type = USB_INVALID_CHARGER;
                         otg->state = OTG_STATE_B_IDLE;
                         msm_otg_reset(otg);
                         schedule_work(w);
@@ -862,12 +1447,31 @@ static int __init msm_otg_probe(struct platform_device *pdev)
                 ret = PTR_ERR(motg->clk);
                 goto put_phy_reset_clk;
         }
+        clk_set_rate(motg->clk, 60000000);
+
+        /*
+         * If USB Core is running its protocol engine based on CORE CLK,
+         * CORE CLK  must be running at >55Mhz for correct HSUSB
+         * operation and USB core cannot tolerate frequency changes on
+         * CORE CLK. For such USB cores, vote for maximum clk frequency
+         * on pclk source
+         */
+         if (motg->pdata->pclk_src_name) {
+                motg->pclk_src = clk_get(&pdev->dev,
+                        motg->pdata->pclk_src_name);
+                if (IS_ERR(motg->pclk_src))
+                        goto put_clk;
+                clk_set_rate(motg->pclk_src, INT_MAX);
+                clk_enable(motg->pclk_src);
+        } else
+                motg->pclk_src = ERR_PTR(-ENOENT);
+
 
         motg->pclk = clk_get(&pdev->dev, "usb_hs_pclk");
         if (IS_ERR(motg->pclk)) {
                 dev_err(&pdev->dev, "failed to get usb_hs_pclk\n");
                 ret = PTR_ERR(motg->pclk);
-                goto put_clk;
+                goto put_pclk_src;
         }
 
         /*
@@ -903,6 +1507,24 @@ static int __init msm_otg_probe(struct platform_device *pdev)
 
         clk_enable(motg->clk);
         clk_enable(motg->pclk);
+
+        ret = msm_hsusb_init_vddcx(motg, 1);
+        if (ret) {
+                dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");
+                goto free_regs;
+        }
+
+        ret = msm_hsusb_ldo_init(motg, 1);
+        if (ret) {
+                dev_err(&pdev->dev, "hsusb vreg configuration failed\n");
+                goto vddcx_exit;
+        }
+        ret = msm_hsusb_ldo_set_mode(1);
+        if (ret) {
+                dev_err(&pdev->dev, "hsusb vreg enable failed\n");
+                goto ldo_exit;
+        }
+
         if (motg->core_clk)
                 clk_enable(motg->core_clk);
 
@@ -910,6 +1532,7 @@ static int __init msm_otg_probe(struct platform_device *pdev)
         writel(0, USB_OTGSC);
 
         INIT_WORK(&motg->sm_work, msm_otg_sm_work);
+        INIT_DELAYED_WORK(&motg->chg_work, msm_chg_detect_work);
         ret = request_irq(motg->irq, msm_otg_irq, IRQF_SHARED,
                                         "msm_otg", motg);
         if (ret) {
@@ -920,6 +1543,7 @@ static int __init msm_otg_probe(struct platform_device *pdev)
         otg->init = msm_otg_reset;
         otg->set_host = msm_otg_set_host;
         otg->set_peripheral = msm_otg_set_peripheral;
+        otg->set_power = msm_otg_set_power;
 
         otg->io_ops = &msm_otg_io_ops;
 
@@ -949,12 +1573,21 @@ free_irq:
 disable_clks:
         clk_disable(motg->pclk);
         clk_disable(motg->clk);
+ldo_exit:
+        msm_hsusb_ldo_init(motg, 0);
+vddcx_exit:
+        msm_hsusb_init_vddcx(motg, 0);
 free_regs:
         iounmap(motg->regs);
 put_core_clk:
         if (motg->core_clk)
                 clk_put(motg->core_clk);
         clk_put(motg->pclk);
+put_pclk_src:
+        if (!IS_ERR(motg->pclk_src)) {
+                clk_disable(motg->pclk_src);
+                clk_put(motg->pclk_src);
+        }
 put_clk:
         clk_put(motg->clk);
 put_phy_reset_clk:
@@ -974,6 +1607,7 @@ static int __devexit msm_otg_remove(struct platform_device *pdev)
                 return -EBUSY;
 
         msm_otg_debugfs_cleanup();
+        cancel_delayed_work_sync(&motg->chg_work);
         cancel_work_sync(&motg->sm_work);
 
         pm_runtime_resume(&pdev->dev);
@@ -1004,6 +1638,11 @@ static int __devexit msm_otg_remove(struct platform_device *pdev)
         clk_disable(motg->clk);
         if (motg->core_clk)
                 clk_disable(motg->core_clk);
+        if (!IS_ERR(motg->pclk_src)) {
+                clk_disable(motg->pclk_src);
+                clk_put(motg->pclk_src);
+        }
+        msm_hsusb_ldo_init(motg, 0);
 
         iounmap(motg->regs);
         pm_runtime_set_suspended(&pdev->dev);
diff --git a/drivers/usb/otg/otg.c b/drivers/usb/otg/otg.c
index 0a43a7db750f..fb7adeff9ffa 100644
--- a/drivers/usb/otg/otg.c
+++ b/drivers/usb/otg/otg.c
@@ -64,3 +64,38 @@ int otg_set_transceiver(struct otg_transceiver *x)
         return 0;
 }
 EXPORT_SYMBOL(otg_set_transceiver);
+
+const char *otg_state_string(enum usb_otg_state state)
+{
+        switch (state) {
+        case OTG_STATE_A_IDLE:
+                return "a_idle";
+        case OTG_STATE_A_WAIT_VRISE:
+                return "a_wait_vrise";
+        case OTG_STATE_A_WAIT_BCON:
+                return "a_wait_bcon";
+        case OTG_STATE_A_HOST:
+                return "a_host";
+        case OTG_STATE_A_SUSPEND:
+                return "a_suspend";
+        case OTG_STATE_A_PERIPHERAL:
+                return "a_peripheral";
+        case OTG_STATE_A_WAIT_VFALL:
+                return "a_wait_vfall";
+        case OTG_STATE_A_VBUS_ERR:
+                return "a_vbus_err";
+        case OTG_STATE_B_IDLE:
+                return "b_idle";
+        case OTG_STATE_B_SRP_INIT:
+                return "b_srp_init";
+        case OTG_STATE_B_PERIPHERAL:
+                return "b_peripheral";
+        case OTG_STATE_B_WAIT_ACON:
+                return "b_wait_acon";
+        case OTG_STATE_B_HOST:
+                return "b_host";
+        default:
+                return "UNDEFINED";
+        }
+}
+EXPORT_SYMBOL(otg_state_string);
diff --git a/drivers/usb/otg/otg_fsm.c b/drivers/usb/otg/otg_fsm.c
new file mode 100644
index 000000000000..b0cc422f2ff9
--- /dev/null
+++ b/drivers/usb/otg/otg_fsm.c
@@ -0,0 +1,349 @@
+/*
+ * OTG Finite State Machine from OTG spec
+ *
+ * Copyright (C) 2007,2008 Freescale Semiconductor, Inc.
+ *
+ * Author:      Li Yang <LeoLi@freescale.com>
+ *              Jerry Huang <Chang-Ming.Huang@freescale.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the  GNU General Public License along
+ * with this program; if not, write  to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/usb.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/otg.h>
+#include <linux/types.h>
+
+#include "otg_fsm.h"
+
+/* Change USB protocol when there is a protocol change */
+static int otg_set_protocol(struct otg_fsm *fsm, int protocol)
+{
+        int ret = 0;
+
+        if (fsm->protocol != protocol) {
+                VDBG("Changing role fsm->protocol= %d; new protocol= %d\n",
+                        fsm->protocol, protocol);
+                /* stop old protocol */
+                if (fsm->protocol == PROTO_HOST)
+                        ret = fsm->ops->start_host(fsm, 0);
+                else if (fsm->protocol == PROTO_GADGET)
+                        ret = fsm->ops->start_gadget(fsm, 0);
+                if (ret)
+                        return ret;
+
+                /* start new protocol */
+                if (protocol == PROTO_HOST)
+                        ret = fsm->ops->start_host(fsm, 1);
+                else if (protocol == PROTO_GADGET)
+                        ret = fsm->ops->start_gadget(fsm, 1);
+                if (ret)
+                        return ret;
+
+                fsm->protocol = protocol;
+                return 0;
+        }
+
+        return 0;
+}
+
+static int state_changed;
+
+/* Called when leaving a state.  Do state clean up jobs here */
+void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state)
+{
+        switch (old_state) {
+        case OTG_STATE_B_IDLE:
+                otg_del_timer(fsm, b_se0_srp_tmr);
+                fsm->b_se0_srp = 0;
+                break;
+        case OTG_STATE_B_SRP_INIT:
+                fsm->b_srp_done = 0;
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                break;
+        case OTG_STATE_B_WAIT_ACON:
+                otg_del_timer(fsm, b_ase0_brst_tmr);
+                fsm->b_ase0_brst_tmout = 0;
+                break;
+        case OTG_STATE_B_HOST:
+                break;
+        case OTG_STATE_A_IDLE:
+                break;
+        case OTG_STATE_A_WAIT_VRISE:
+                otg_del_timer(fsm, a_wait_vrise_tmr);
+                fsm->a_wait_vrise_tmout = 0;
+                break;
+        case OTG_STATE_A_WAIT_BCON:
+                otg_del_timer(fsm, a_wait_bcon_tmr);
+                fsm->a_wait_bcon_tmout = 0;
+                break;
+        case OTG_STATE_A_HOST:
+                otg_del_timer(fsm, a_wait_enum_tmr);
+                break;
+        case OTG_STATE_A_SUSPEND:
+                otg_del_timer(fsm, a_aidl_bdis_tmr);
+                fsm->a_aidl_bdis_tmout = 0;
+                fsm->a_suspend_req = 0;
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                break;
+        case OTG_STATE_A_WAIT_VFALL:
+                otg_del_timer(fsm, a_wait_vrise_tmr);
+                break;
+        case OTG_STATE_A_VBUS_ERR:
+                break;
+        default:
+                break;
+        }
+}
+
+/* Called when entering a state */
+int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
+{
+        state_changed = 1;
+        if (fsm->transceiver->state == new_state)
+                return 0;
+        VDBG("Set state: %s\n", otg_state_string(new_state));
+        otg_leave_state(fsm, fsm->transceiver->state);
+        switch (new_state) {
+        case OTG_STATE_B_IDLE:
+                otg_drv_vbus(fsm, 0);
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_UNDEF);
+                otg_add_timer(fsm, b_se0_srp_tmr);
+                break;
+        case OTG_STATE_B_SRP_INIT:
+                otg_start_pulse(fsm);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_UNDEF);
+                otg_add_timer(fsm, b_srp_fail_tmr);
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 1);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_GADGET);
+                break;
+        case OTG_STATE_B_WAIT_ACON:
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                otg_add_timer(fsm, b_ase0_brst_tmr);
+                fsm->a_bus_suspend = 0;
+                break;
+        case OTG_STATE_B_HOST:
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 1);
+                otg_set_protocol(fsm, PROTO_HOST);
+                usb_bus_start_enum(fsm->transceiver->host,
+                                fsm->transceiver->host->otg_port);
+                break;
+        case OTG_STATE_A_IDLE:
+                otg_drv_vbus(fsm, 0);
+                otg_chrg_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                break;
+        case OTG_STATE_A_WAIT_VRISE:
+                otg_drv_vbus(fsm, 1);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                otg_add_timer(fsm, a_wait_vrise_tmr);
+                break;
+        case OTG_STATE_A_WAIT_BCON:
+                otg_drv_vbus(fsm, 1);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                otg_add_timer(fsm, a_wait_bcon_tmr);
+                break;
+        case OTG_STATE_A_HOST:
+                otg_drv_vbus(fsm, 1);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 1);
+                otg_set_protocol(fsm, PROTO_HOST);
+                /*
+                 * When HNP is triggered while a_bus_req = 0, a_host will
+                 * suspend too fast to complete a_set_b_hnp_en
+                 */
+                if (!fsm->a_bus_req || fsm->a_suspend_req)
+                        otg_add_timer(fsm, a_wait_enum_tmr);
+                break;
+        case OTG_STATE_A_SUSPEND:
+                otg_drv_vbus(fsm, 1);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                otg_add_timer(fsm, a_aidl_bdis_tmr);
+
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                otg_loc_conn(fsm, 1);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_GADGET);
+                otg_drv_vbus(fsm, 1);
+                break;
+        case OTG_STATE_A_WAIT_VFALL:
+                otg_drv_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_HOST);
+                break;
+        case OTG_STATE_A_VBUS_ERR:
+                otg_drv_vbus(fsm, 0);
+                otg_loc_conn(fsm, 0);
+                otg_loc_sof(fsm, 0);
+                otg_set_protocol(fsm, PROTO_UNDEF);
+                break;
+        default:
+                break;
+        }
+
+        fsm->transceiver->state = new_state;
+        return 0;
+}
+
+/* State change judgement */
+int otg_statemachine(struct otg_fsm *fsm)
+{
+        enum usb_otg_state state;
+        unsigned long flags;
+
+        spin_lock_irqsave(&fsm->lock, flags);
+
+        state = fsm->transceiver->state;
+        state_changed = 0;
+        /* State machine state change judgement */
+
+        switch (state) {
+        case OTG_STATE_UNDEFINED:
+                VDBG("fsm->id = %d\n", fsm->id);
+                if (fsm->id)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else
+                        otg_set_state(fsm, OTG_STATE_A_IDLE);
+                break;
+        case OTG_STATE_B_IDLE:
+                if (!fsm->id)
+                        otg_set_state(fsm, OTG_STATE_A_IDLE);
+                else if (fsm->b_sess_vld && fsm->transceiver->gadget)
+                        otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
+                else if (fsm->b_bus_req && fsm->b_sess_end && fsm->b_se0_srp)
+                        otg_set_state(fsm, OTG_STATE_B_SRP_INIT);
+                break;
+        case OTG_STATE_B_SRP_INIT:
+                if (!fsm->id || fsm->b_srp_done)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                if (!fsm->id || !fsm->b_sess_vld)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else if (fsm->b_bus_req && fsm->transceiver->
+                                gadget->b_hnp_enable && fsm->a_bus_suspend)
+                        otg_set_state(fsm, OTG_STATE_B_WAIT_ACON);
+                break;
+        case OTG_STATE_B_WAIT_ACON:
+                if (fsm->a_conn)
+                        otg_set_state(fsm, OTG_STATE_B_HOST);
+                else if (!fsm->id || !fsm->b_sess_vld)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else if (fsm->a_bus_resume || fsm->b_ase0_brst_tmout) {
+                        fsm->b_ase0_brst_tmout = 0;
+                        otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
+                }
+                break;
+        case OTG_STATE_B_HOST:
+                if (!fsm->id || !fsm->b_sess_vld)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else if (!fsm->b_bus_req || !fsm->a_conn)
+                        otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
+                break;
+        case OTG_STATE_A_IDLE:
+                if (fsm->id)
+                        otg_set_state(fsm, OTG_STATE_B_IDLE);
+                else if (!fsm->a_bus_drop && (fsm->a_bus_req || fsm->a_srp_det))
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VRISE);
+                break;
+        case OTG_STATE_A_WAIT_VRISE:
+                if (fsm->id || fsm->a_bus_drop || fsm->a_vbus_vld ||
+                                fsm->a_wait_vrise_tmout) {
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+                }
+                break;
+        case OTG_STATE_A_WAIT_BCON:
+                if (!fsm->a_vbus_vld)
+                        otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+                else if (fsm->b_conn)
+                        otg_set_state(fsm, OTG_STATE_A_HOST);
+                else if (fsm->id | fsm->a_bus_drop | fsm->a_wait_bcon_tmout)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+                break;
+        case OTG_STATE_A_HOST:
+                if ((!fsm->a_bus_req || fsm->a_suspend_req) &&
+                                fsm->transceiver->host->b_hnp_enable)
+                        otg_set_state(fsm, OTG_STATE_A_SUSPEND);
+                else if (fsm->id || !fsm->b_conn || fsm->a_bus_drop)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+                else if (!fsm->a_vbus_vld)
+                        otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+                break;
+        case OTG_STATE_A_SUSPEND:
+                if (!fsm->b_conn && fsm->transceiver->host->b_hnp_enable)
+                        otg_set_state(fsm, OTG_STATE_A_PERIPHERAL);
+                else if (!fsm->b_conn && !fsm->transceiver->host->b_hnp_enable)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+                else if (fsm->a_bus_req || fsm->b_bus_resume)
+                        otg_set_state(fsm, OTG_STATE_A_HOST);
+                else if (fsm->id || fsm->a_bus_drop || fsm->a_aidl_bdis_tmout)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+                else if (!fsm->a_vbus_vld)
+                        otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                if (fsm->id || fsm->a_bus_drop)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+                else if (fsm->b_bus_suspend)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+                else if (!fsm->a_vbus_vld)
+                        otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+                break;
+        case OTG_STATE_A_WAIT_VFALL:
+                if (fsm->id || fsm->a_bus_req || (!fsm->a_sess_vld &&
+                                        !fsm->b_conn))
+                        otg_set_state(fsm, OTG_STATE_A_IDLE);
+                break;
+        case OTG_STATE_A_VBUS_ERR:
+                if (fsm->id || fsm->a_bus_drop || fsm->a_clr_err)
+                        otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+                break;
+        default:
+                break;
+        }
+        spin_unlock_irqrestore(&fsm->lock, flags);
+
+        VDBG("quit statemachine, changed = %d\n", state_changed);
+        return state_changed;
+}
diff --git a/drivers/usb/otg/otg_fsm.h b/drivers/usb/otg/otg_fsm.h
new file mode 100644
index 000000000000..0cecf1d593a0
--- /dev/null
+++ b/drivers/usb/otg/otg_fsm.h
@@ -0,0 +1,154 @@
+/* Copyright (C) 2007,2008 Freescale Semiconductor, 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, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the  GNU General Public License along
+ * with this program; if not, write  to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#undef DEBUG
+#undef VERBOSE
+
+#ifdef DEBUG
+#define DBG(fmt, args...) printk(KERN_DEBUG "[%s]  " fmt , \
+                                 __func__, ## args)
+#else
+#define DBG(fmt, args...)       do {} while (0)
+#endif
+
+#ifdef VERBOSE
+#define VDBG            DBG
+#else
+#define VDBG(stuff...)  do {} while (0)
+#endif
+
+#ifdef VERBOSE
+#define MPC_LOC printk("Current Location [%s]:[%d]\n", __FILE__, __LINE__)
+#else
+#define MPC_LOC do {} while (0)
+#endif
+
+#define PROTO_UNDEF     (0)
+#define PROTO_HOST      (1)
+#define PROTO_GADGET    (2)
+
+/* OTG state machine according to the OTG spec */
+struct otg_fsm {
+        /* Input */
+        int a_bus_resume;
+        int a_bus_suspend;
+        int a_conn;
+        int a_sess_vld;
+        int a_srp_det;
+        int a_vbus_vld;
+        int b_bus_resume;
+        int b_bus_suspend;
+        int b_conn;
+        int b_se0_srp;
+        int b_sess_end;
+        int b_sess_vld;
+        int id;
+
+        /* Internal variables */
+        int a_set_b_hnp_en;
+        int b_srp_done;
+        int b_hnp_enable;
+
+        /* Timeout indicator for timers */
+        int a_wait_vrise_tmout;
+        int a_wait_bcon_tmout;
+        int a_aidl_bdis_tmout;
+        int b_ase0_brst_tmout;
+
+        /* Informative variables */
+        int a_bus_drop;
+        int a_bus_req;
+        int a_clr_err;
+        int a_suspend_req;
+        int b_bus_req;
+
+        /* Output */
+        int drv_vbus;
+        int loc_conn;
+        int loc_sof;
+
+        struct otg_fsm_ops *ops;
+        struct otg_transceiver *transceiver;
+
+        /* Current usb protocol used: 0:undefine; 1:host; 2:client */
+        int protocol;
+        spinlock_t lock;
+};
+
+struct otg_fsm_ops {
+        void    (*chrg_vbus)(int on);
+        void    (*drv_vbus)(int on);
+        void    (*loc_conn)(int on);
+        void    (*loc_sof)(int on);
+        void    (*start_pulse)(void);
+        void    (*add_timer)(void *timer);
+        void    (*del_timer)(void *timer);
+        int     (*start_host)(struct otg_fsm *fsm, int on);
+        int     (*start_gadget)(struct otg_fsm *fsm, int on);
+};
+
+
+static inline void otg_chrg_vbus(struct otg_fsm *fsm, int on)
+{
+        fsm->ops->chrg_vbus(on);
+}
+
+static inline void otg_drv_vbus(struct otg_fsm *fsm, int on)
+{
+        if (fsm->drv_vbus != on) {
+                fsm->drv_vbus = on;
+                fsm->ops->drv_vbus(on);
+        }
+}
+
+static inline void otg_loc_conn(struct otg_fsm *fsm, int on)
+{
+        if (fsm->loc_conn != on) {
+                fsm->loc_conn = on;
+                fsm->ops->loc_conn(on);
+        }
+}
+
+static inline void otg_loc_sof(struct otg_fsm *fsm, int on)
+{
+        if (fsm->loc_sof != on) {
+                fsm->loc_sof = on;
+                fsm->ops->loc_sof(on);
+        }
+}
+
+static inline void otg_start_pulse(struct otg_fsm *fsm)
+{
+        fsm->ops->start_pulse();
+}
+
+static inline void otg_add_timer(struct otg_fsm *fsm, void *timer)
+{
+        fsm->ops->add_timer(timer);
+}
+
+static inline void otg_del_timer(struct otg_fsm *fsm, void *timer)
+{
+        fsm->ops->del_timer(timer);
+}
+
+int otg_statemachine(struct otg_fsm *fsm);
+
+/* Defined by device specific driver, for different timer implementation */
+extern struct fsl_otg_timer *a_wait_vrise_tmr, *a_wait_bcon_tmr,
+        *a_aidl_bdis_tmr, *b_ase0_brst_tmr, *b_se0_srp_tmr, *b_srp_fail_tmr,
+        *a_wait_enum_tmr;
diff --git a/drivers/usb/otg/twl4030-usb.c b/drivers/usb/otg/twl4030-usb.c
index e01b073cc489..efeb4d1517ff 100644
--- a/drivers/usb/otg/twl4030-usb.c
+++ b/drivers/usb/otg/twl4030-usb.c
@@ -160,6 +160,7 @@ struct twl4030_usb {
 
         int                     irq;
         u8                      linkstat;
+        bool                    vbus_supplied;
         u8                      asleep;
         bool                    irq_enabled;
 };
@@ -250,6 +251,8 @@ static enum usb_xceiv_events twl4030_usb_linkstat(struct twl4030_usb *twl)
         int     status;
         int     linkstat = USB_EVENT_NONE;
 
+        twl->vbus_supplied = false;
+
         /*
          * For ID/VBUS sensing, see manual section 15.4.8 ...
          * except when using only battery backup power, two
@@ -265,6 +268,9 @@ static enum usb_xceiv_events twl4030_usb_linkstat(struct twl4030_usb *twl)
         if (status < 0)
                 dev_err(twl->dev, "USB link status err %d\n", status);
         else if (status & (BIT(7) | BIT(2))) {
+                if (status & (BIT(7)))
+                        twl->vbus_supplied = true;
+
                 if (status & BIT(2))
                         linkstat = USB_EVENT_ID;
                 else
@@ -484,7 +490,7 @@ static ssize_t twl4030_usb_vbus_show(struct device *dev,
 
         spin_lock_irqsave(&twl->lock, flags);
         ret = sprintf(buf, "%s\n",
-                        (twl->linkstat == USB_EVENT_VBUS) ? "on" : "off");
+                        twl->vbus_supplied ? "on" : "off");
         spin_unlock_irqrestore(&twl->lock, flags);
 
         return ret;
@@ -608,6 +614,7 @@ static int __devinit twl4030_usb_probe(struct platform_device *pdev)
         twl->otg.set_peripheral = twl4030_set_peripheral;
         twl->otg.set_suspend    = twl4030_set_suspend;
         twl->usb_mode           = pdata->usb_mode;
+        twl->vbus_supplied      = false;
         twl->asleep = 1;
 
         /* init spinlock for workqueue */
diff --git a/drivers/usb/otg/twl6030-usb.c b/drivers/usb/otg/twl6030-usb.c
index 8a91b4b832a1..6e920de64ef6 100644
--- a/drivers/usb/otg/twl6030-usb.c
+++ b/drivers/usb/otg/twl6030-usb.c
@@ -101,7 +101,7 @@ struct twl6030_usb {
         bool                    irq_enabled;
 };
 
-#define xceiv_to_twl(x)         container_of((x), struct twl6030_usb, otg);
+#define xceiv_to_twl(x)         container_of((x), struct twl6030_usb, otg)
 
 /*-------------------------------------------------------------------------*/
 
diff --git a/drivers/usb/renesas_usbhs/Kconfig b/drivers/usb/renesas_usbhs/Kconfig
new file mode 100644
index 000000000000..b2e64918884c
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/Kconfig
@@ -0,0 +1,16 @@
+#
+# Renesas USB Controller Drivers
+#
+
+config USB_RENESAS_USBHS
+        tristate 'Renesas USBHS controller'
+        depends on SUPERH || ARCH_SHMOBILE
+        default n
+        help
+           Renesas USBHS is a discrete USB host and peripheral controller chip
+           that supports both full and high speed USB 2.0 data transfers.
+           It has nine or more configurable endpoints, and endpoint zero.
+
+           Say "y" to link the driver statically, or "m" to build a
+           dynamically linked module called "renesas_usbhs" and force all
+           gadget drivers to also be dynamically linked.
diff --git a/drivers/usb/renesas_usbhs/Makefile b/drivers/usb/renesas_usbhs/Makefile
new file mode 100644
index 000000000000..b8798ad16278
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/Makefile
@@ -0,0 +1,9 @@
+#
+# for Renesas USB
+#
+
+obj-$(CONFIG_USB_RENESAS_USBHS) += renesas_usbhs.o
+
+renesas_usbhs-y                 := common.o mod.o pipe.o
+
+renesas_usbhs-$(CONFIG_USB_RENESAS_USBHS_UDC)   += mod_gadget.o
diff --git a/drivers/usb/renesas_usbhs/common.c b/drivers/usb/renesas_usbhs/common.c
new file mode 100644
index 000000000000..34e68e0205c5
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/common.c
@@ -0,0 +1,437 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/pm_runtime.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include "./common.h"
+
+#define USBHSF_RUNTIME_PWCTRL   (1 << 0)
+
+/* status */
+#define usbhsc_flags_init(p)   do {(p)->flags = 0; } while (0)
+#define usbhsc_flags_set(p, b) ((p)->flags |=  (b))
+#define usbhsc_flags_clr(p, b) ((p)->flags &= ~(b))
+#define usbhsc_flags_has(p, b) ((p)->flags &   (b))
+
+/*
+ * platform call back
+ *
+ * renesas usb support platform callback function.
+ * Below macro call it.
+ * if platform doesn't have callback, it return 0 (no error)
+ */
+#define usbhs_platform_call(priv, func, args...)\
+        (!(priv) ? -ENODEV :                    \
+         !((priv)->pfunc->func) ? 0 :           \
+         (priv)->pfunc->func(args))
+
+/*
+ *              common functions
+ */
+u16 usbhs_read(struct usbhs_priv *priv, u32 reg)
+{
+        return ioread16(priv->base + reg);
+}
+
+void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data)
+{
+        iowrite16(data, priv->base + reg);
+}
+
+void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data)
+{
+        u16 val = usbhs_read(priv, reg);
+
+        val &= ~mask;
+        val |= data & mask;
+
+        usbhs_write(priv, reg, val);
+}
+
+struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev)
+{
+        return dev_get_drvdata(&pdev->dev);
+}
+
+/*
+ *              syscfg functions
+ */
+void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable)
+{
+        usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0);
+}
+
+void usbhs_sys_hispeed_ctrl(struct usbhs_priv *priv, int enable)
+{
+        usbhs_bset(priv, SYSCFG, HSE, enable ? HSE : 0);
+}
+
+void usbhs_sys_usb_ctrl(struct usbhs_priv *priv, int enable)
+{
+        usbhs_bset(priv, SYSCFG, USBE, enable ? USBE : 0);
+}
+
+void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable)
+{
+        u16 mask = DCFM | DRPD | DPRPU;
+        u16 val  = DCFM | DRPD;
+
+        /*
+         * if enable
+         *
+         * - select Host mode
+         * - D+ Line/D- Line Pull-down
+         */
+        usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
+}
+
+void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable)
+{
+        u16 mask = DCFM | DRPD | DPRPU;
+        u16 val  = DPRPU;
+
+        /*
+         * if enable
+         *
+         * - select Function mode
+         * - D+ Line Pull-up
+         */
+        usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
+}
+
+/*
+ *              frame functions
+ */
+int usbhs_frame_get_num(struct usbhs_priv *priv)
+{
+        return usbhs_read(priv, FRMNUM) & FRNM_MASK;
+}
+
+/*
+ *              local functions
+ */
+static void usbhsc_bus_ctrl(struct usbhs_priv *priv, int enable)
+{
+        int wait = usbhs_get_dparam(priv, buswait_bwait);
+        u16 data = 0;
+
+        if (enable) {
+                /* set bus wait if platform have */
+                if (wait)
+                        usbhs_bset(priv, BUSWAIT, 0x000F, wait);
+        }
+        usbhs_write(priv, DVSTCTR, data);
+}
+
+/*
+ *              platform default param
+ */
+static u32 usbhsc_default_pipe_type[] = {
+                USB_ENDPOINT_XFER_CONTROL,
+                USB_ENDPOINT_XFER_ISOC,
+                USB_ENDPOINT_XFER_ISOC,
+                USB_ENDPOINT_XFER_BULK,
+                USB_ENDPOINT_XFER_BULK,
+                USB_ENDPOINT_XFER_BULK,
+                USB_ENDPOINT_XFER_INT,
+                USB_ENDPOINT_XFER_INT,
+                USB_ENDPOINT_XFER_INT,
+                USB_ENDPOINT_XFER_INT,
+};
+
+/*
+ *              power control
+ */
+static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable)
+{
+        struct device *dev = usbhs_priv_to_dev(priv);
+
+        if (enable) {
+                /* enable PM */
+                pm_runtime_get_sync(dev);
+
+                /* USB on */
+                usbhs_sys_clock_ctrl(priv, enable);
+                usbhsc_bus_ctrl(priv, enable);
+        } else {
+                /* USB off */
+                usbhsc_bus_ctrl(priv, enable);
+                usbhs_sys_clock_ctrl(priv, enable);
+
+                /* disable PM */
+                pm_runtime_put_sync(dev);
+        }
+}
+
+/*
+ *              notify hotplug
+ */
+static void usbhsc_notify_hotplug(struct work_struct *work)
+{
+        struct usbhs_priv *priv = container_of(work,
+                                               struct usbhs_priv,
+                                               notify_hotplug_work.work);
+        struct platform_device *pdev = usbhs_priv_to_pdev(priv);
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+        int id;
+        int enable;
+        int ret;
+
+        /*
+         * get vbus status from platform
+         */
+        enable = usbhs_platform_call(priv, get_vbus, pdev);
+
+        /*
+         * get id from platform
+         */
+        id = usbhs_platform_call(priv, get_id, pdev);
+
+        if (enable && !mod) {
+                ret = usbhs_mod_change(priv, id);
+                if (ret < 0)
+                        return;
+
+                dev_dbg(&pdev->dev, "%s enable\n", __func__);
+
+                /* power on */
+                if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
+                        usbhsc_power_ctrl(priv, enable);
+
+                /* module start */
+                usbhs_mod_call(priv, start, priv);
+
+        } else if (!enable && mod) {
+                dev_dbg(&pdev->dev, "%s disable\n", __func__);
+
+                /* module stop */
+                usbhs_mod_call(priv, stop, priv);
+
+                /* power off */
+                if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
+                        usbhsc_power_ctrl(priv, enable);
+
+                usbhs_mod_change(priv, -1);
+
+                /* reset phy for next connection */
+                usbhs_platform_call(priv, phy_reset, pdev);
+        }
+}
+
+int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev)
+{
+        struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
+        int delay = usbhs_get_dparam(priv, detection_delay);
+
+        /*
+         * This functions will be called in interrupt.
+         * To make sure safety context,
+         * use workqueue for usbhs_notify_hotplug
+         */
+        schedule_delayed_work(&priv->notify_hotplug_work, delay);
+        return 0;
+}
+
+/*
+ *              platform functions
+ */
+static int __devinit usbhs_probe(struct platform_device *pdev)
+{
+        struct renesas_usbhs_platform_info *info = pdev->dev.platform_data;
+        struct renesas_usbhs_driver_callback *dfunc;
+        struct usbhs_priv *priv;
+        struct resource *res;
+        unsigned int irq;
+        int ret;
+
+        /* check platform information */
+        if (!info ||
+            !info->platform_callback.get_id) {
+                dev_err(&pdev->dev, "no platform information\n");
+                return -EINVAL;
+        }
+
+        /* platform data */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        irq = platform_get_irq(pdev, 0);
+        if (!res || (int)irq <= 0) {
+                dev_err(&pdev->dev, "Not enough Renesas USB platform resources.\n");
+                return -ENODEV;
+        }
+
+        /* usb private data */
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                dev_err(&pdev->dev, "Could not allocate priv\n");
+                return -ENOMEM;
+        }
+
+        priv->base = ioremap_nocache(res->start, resource_size(res));
+        if (!priv->base) {
+                dev_err(&pdev->dev, "ioremap error.\n");
+                ret = -ENOMEM;
+                goto probe_end_kfree;
+        }
+
+        /*
+         * care platform info
+         */
+        priv->pfunc     = &info->platform_callback;
+        priv->dparam    = &info->driver_param;
+
+        /* set driver callback functions for platform */
+        dfunc                   = &info->driver_callback;
+        dfunc->notify_hotplug   = usbhsc_drvcllbck_notify_hotplug;
+
+        /* set default param if platform doesn't have */
+        if (!priv->dparam->pipe_type) {
+                priv->dparam->pipe_type = usbhsc_default_pipe_type;
+                priv->dparam->pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type);
+        }
+
+        /* FIXME */
+        /* runtime power control ? */
+        if (priv->pfunc->get_vbus)
+                usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL);
+
+        /*
+         * priv settings
+         */
+        priv->irq       = irq;
+        priv->pdev      = pdev;
+        INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug);
+        spin_lock_init(usbhs_priv_to_lock(priv));
+
+        /* call pipe and module init */
+        ret = usbhs_pipe_probe(priv);
+        if (ret < 0)
+                goto probe_end_mod_exit;
+
+        ret = usbhs_mod_probe(priv);
+        if (ret < 0)
+                goto probe_end_iounmap;
+
+        /* dev_set_drvdata should be called after usbhs_mod_init */
+        dev_set_drvdata(&pdev->dev, priv);
+
+        /*
+         * deviece reset here because
+         * USB device might be used in boot loader.
+         */
+        usbhs_sys_clock_ctrl(priv, 0);
+
+        /*
+         * platform call
+         *
+         * USB phy setup might depend on CPU/Board.
+         * If platform has its callback functions,
+         * call it here.
+         */
+        ret = usbhs_platform_call(priv, hardware_init, pdev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "platform prove failed.\n");
+                goto probe_end_pipe_exit;
+        }
+
+        /* reset phy for connection */
+        usbhs_platform_call(priv, phy_reset, pdev);
+
+        /* power control */
+        pm_runtime_enable(&pdev->dev);
+        if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) {
+                usbhsc_power_ctrl(priv, 1);
+                usbhs_mod_autonomy_mode(priv);
+        }
+
+        /*
+         * manual call notify_hotplug for cold plug
+         */
+        ret = usbhsc_drvcllbck_notify_hotplug(pdev);
+        if (ret < 0)
+                goto probe_end_call_remove;
+
+        dev_info(&pdev->dev, "probed\n");
+
+        return ret;
+
+probe_end_call_remove:
+        usbhs_platform_call(priv, hardware_exit, pdev);
+probe_end_pipe_exit:
+        usbhs_pipe_remove(priv);
+probe_end_mod_exit:
+        usbhs_mod_remove(priv);
+probe_end_iounmap:
+        iounmap(priv->base);
+probe_end_kfree:
+        kfree(priv);
+
+        dev_info(&pdev->dev, "probe failed\n");
+
+        return ret;
+}
+
+static int __devexit usbhs_remove(struct platform_device *pdev)
+{
+        struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
+        struct renesas_usbhs_platform_info *info = pdev->dev.platform_data;
+        struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback;
+
+        dev_dbg(&pdev->dev, "usb remove\n");
+
+        dfunc->notify_hotplug = NULL;
+
+        /* power off */
+        if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
+                usbhsc_power_ctrl(priv, 0);
+
+        pm_runtime_disable(&pdev->dev);
+
+        usbhs_platform_call(priv, hardware_exit, pdev);
+        usbhs_pipe_remove(priv);
+        usbhs_mod_remove(priv);
+        iounmap(priv->base);
+        kfree(priv);
+
+        return 0;
+}
+
+static struct platform_driver renesas_usbhs_driver = {
+        .driver         = {
+                .name   = "renesas_usbhs",
+        },
+        .probe          = usbhs_probe,
+        .remove         = __devexit_p(usbhs_remove),
+};
+
+static int __init usbhs_init(void)
+{
+        return platform_driver_register(&renesas_usbhs_driver);
+}
+
+static void __exit usbhs_exit(void)
+{
+        platform_driver_unregister(&renesas_usbhs_driver);
+}
+
+module_init(usbhs_init);
+module_exit(usbhs_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Renesas USB driver");
+MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
diff --git a/drivers/usb/renesas_usbhs/common.h b/drivers/usb/renesas_usbhs/common.h
new file mode 100644
index 000000000000..0aadcb402764
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/common.h
@@ -0,0 +1,230 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#ifndef RENESAS_USB_DRIVER_H
+#define RENESAS_USB_DRIVER_H
+
+#include <linux/platform_device.h>
+#include <linux/usb/renesas_usbhs.h>
+
+struct usbhs_priv;
+
+#include "./mod.h"
+#include "./pipe.h"
+
+/*
+ *
+ *              register define
+ *
+ */
+#define SYSCFG          0x0000
+#define BUSWAIT         0x0002
+#define DVSTCTR         0x0008
+#define CFIFO           0x0014
+#define CFIFOSEL        0x0020
+#define CFIFOCTR        0x0022
+#define INTENB0         0x0030
+#define INTENB1         0x0032
+#define BRDYENB         0x0036
+#define NRDYENB         0x0038
+#define BEMPENB         0x003A
+#define INTSTS0         0x0040
+#define INTSTS1         0x0042
+#define BRDYSTS         0x0046
+#define NRDYSTS         0x0048
+#define BEMPSTS         0x004A
+#define FRMNUM          0x004C
+#define USBREQ          0x0054  /* USB request type register */
+#define USBVAL          0x0056  /* USB request value register */
+#define USBINDX         0x0058  /* USB request index register */
+#define USBLENG         0x005A  /* USB request length register */
+#define DCPCFG          0x005C
+#define DCPMAXP         0x005E
+#define DCPCTR          0x0060
+#define PIPESEL         0x0064
+#define PIPECFG         0x0068
+#define PIPEBUF         0x006A
+#define PIPEMAXP        0x006C
+#define PIPEPERI        0x006E
+#define PIPEnCTR        0x0070
+
+/* SYSCFG */
+#define SCKE    (1 << 10)       /* USB Module Clock Enable */
+#define HSE     (1 << 7)        /* High-Speed Operation Enable */
+#define DCFM    (1 << 6)        /* Controller Function Select */
+#define DRPD    (1 << 5)        /* D+ Line/D- Line Resistance Control */
+#define DPRPU   (1 << 4)        /* D+ Line Resistance Control */
+#define USBE    (1 << 0)        /* USB Module Operation Enable */
+
+/* DVSTCTR */
+#define EXTLP   (1 << 10)       /* Controls the EXTLP pin output state */
+#define PWEN    (1 << 9)        /* Controls the PWEN pin output state */
+#define RHST    (0x7)           /* Reset Handshake */
+#define  RHST_LOW_SPEED  1      /* Low-speed connection */
+#define  RHST_FULL_SPEED 2      /* Full-speed connection */
+#define  RHST_HIGH_SPEED 3      /* High-speed connection */
+
+/* CFIFOSEL */
+#define MBW_32  (0x2 << 10)     /* CFIFO Port Access Bit Width */
+
+/* CFIFOCTR */
+#define BVAL    (1 << 15)       /* Buffer Memory Enable Flag */
+#define BCLR    (1 << 14)       /* CPU buffer clear */
+#define FRDY    (1 << 13)       /* FIFO Port Ready */
+#define DTLN_MASK (0x0FFF)      /* Receive Data Length */
+
+/* INTENB0 */
+#define VBSE    (1 << 15)       /* Enable IRQ VBUS_0 and VBUSIN_0 */
+#define RSME    (1 << 14)       /* Enable IRQ Resume */
+#define SOFE    (1 << 13)       /* Enable IRQ Frame Number Update */
+#define DVSE    (1 << 12)       /* Enable IRQ Device State Transition */
+#define CTRE    (1 << 11)       /* Enable IRQ Control Stage Transition */
+#define BEMPE   (1 << 10)       /* Enable IRQ Buffer Empty */
+#define NRDYE   (1 << 9)        /* Enable IRQ Buffer Not Ready Response */
+#define BRDYE   (1 << 8)        /* Enable IRQ Buffer Ready */
+
+/* INTENB1 */
+#define BCHGE   (1 << 14)       /* USB Bus Change Interrupt Enable */
+#define DTCHE   (1 << 12)       /* Disconnection Detect Interrupt Enable */
+#define ATTCHE  (1 << 11)       /* Connection Detect Interrupt Enable */
+#define EOFERRE (1 << 6)        /* EOF Error Detect Interrupt Enable */
+#define SIGNE   (1 << 5)        /* Setup Transaction Error Interrupt Enable */
+#define SACKE   (1 << 4)        /* Setup Transaction ACK Interrupt Enable */
+
+/* INTSTS0 */
+#define VBINT   (1 << 15)       /* VBUS0_0 and VBUS1_0 Interrupt Status */
+#define DVST    (1 << 12)       /* Device State Transition Interrupt Status */
+#define CTRT    (1 << 11)       /* Control Stage Interrupt Status */
+#define BEMP    (1 << 10)       /* Buffer Empty Interrupt Status */
+#define BRDY    (1 << 8)        /* Buffer Ready Interrupt Status */
+#define VBSTS   (1 << 7)        /* VBUS_0 and VBUSIN_0 Input Status */
+#define VALID   (1 << 3)        /* USB Request Receive */
+
+#define DVSQ_MASK               (0x3 << 4)      /* Device State */
+#define  POWER_STATE            (0 << 4)
+#define  DEFAULT_STATE          (1 << 4)
+#define  ADDRESS_STATE          (2 << 4)
+#define  CONFIGURATION_STATE    (3 << 4)
+
+#define CTSQ_MASK               (0x7)   /* Control Transfer Stage */
+#define  IDLE_SETUP_STAGE       0       /* Idle stage or setup stage */
+#define  READ_DATA_STAGE        1       /* Control read data stage */
+#define  READ_STATUS_STAGE      2       /* Control read status stage */
+#define  WRITE_DATA_STAGE       3       /* Control write data stage */
+#define  WRITE_STATUS_STAGE     4       /* Control write status stage */
+#define  NODATA_STATUS_STAGE    5       /* Control write NoData status stage */
+#define  SEQUENCE_ERROR         6       /* Control transfer sequence error */
+
+/* PIPECFG */
+/* DCPCFG */
+#define TYPE_NONE       (0 << 14)       /* Transfer Type */
+#define TYPE_BULK       (1 << 14)
+#define TYPE_INT        (2 << 14)
+#define TYPE_ISO        (3 << 14)
+#define DBLB            (1 << 9)        /* Double Buffer Mode */
+#define SHTNAK          (1 << 7)        /* Pipe Disable in Transfer End */
+#define DIR_OUT         (1 << 4)        /* Transfer Direction */
+
+/* PIPEMAXP */
+/* DCPMAXP */
+#define DEVSEL_MASK     (0xF << 12)     /* Device Select */
+#define DCP_MAXP_MASK   (0x7F)
+#define PIPE_MAXP_MASK  (0x7FF)
+
+/* PIPEBUF */
+#define BUFSIZE_SHIFT   10
+#define BUFSIZE_MASK    (0x1F << BUFSIZE_SHIFT)
+#define BUFNMB_MASK     (0xFF)
+
+/* PIPEnCTR */
+/* DCPCTR */
+#define BSTS            (1 << 15)       /* Buffer Status */
+#define CSSTS           (1 << 12)       /* CSSTS Status */
+#define SQCLR           (1 << 8)        /* Toggle Bit Clear */
+#define ACLRM           (1 << 9)        /* Buffer Auto-Clear Mode */
+#define PBUSY           (1 << 5)        /* Pipe Busy */
+#define PID_MASK        (0x3)           /* Response PID */
+#define  PID_NAK        0
+#define  PID_BUF        1
+#define  PID_STALL10    2
+#define  PID_STALL11    3
+
+#define CCPL            (1 << 2)        /* Control Transfer End Enable */
+
+/* FRMNUM */
+#define FRNM_MASK       (0x7FF)
+
+/*
+ *              struct
+ */
+struct usbhs_priv {
+
+        void __iomem *base;
+        unsigned int irq;
+
+        struct renesas_usbhs_platform_callback  *pfunc;
+        struct renesas_usbhs_driver_param       *dparam;
+
+        struct delayed_work notify_hotplug_work;
+        struct platform_device *pdev;
+
+        spinlock_t              lock;
+
+        u32 flags;
+
+        /*
+         * module control
+         */
+        struct usbhs_mod_info mod_info;
+
+        /*
+         * pipe control
+         */
+        struct usbhs_pipe_info pipe_info;
+};
+
+/*
+ * common
+ */
+u16 usbhs_read(struct usbhs_priv *priv, u32 reg);
+void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data);
+void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data);
+
+int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev);
+/*
+ * sysconfig
+ */
+void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable);
+void usbhs_sys_hispeed_ctrl(struct usbhs_priv *priv, int enable);
+void usbhs_sys_usb_ctrl(struct usbhs_priv *priv, int enable);
+void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable);
+void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable);
+
+/*
+ * frame
+ */
+int usbhs_frame_get_num(struct usbhs_priv *priv);
+
+/*
+ * data
+ */
+struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev);
+#define usbhs_get_dparam(priv, param)   (priv->dparam->param)
+#define usbhs_priv_to_pdev(priv)        (priv->pdev)
+#define usbhs_priv_to_dev(priv)         (&priv->pdev->dev)
+#define usbhs_priv_to_lock(priv)        (&priv->lock)
+
+#endif /* RENESAS_USB_DRIVER_H */
diff --git a/drivers/usb/renesas_usbhs/mod.c b/drivers/usb/renesas_usbhs/mod.c
new file mode 100644
index 000000000000..a577f8f4064c
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/mod.c
@@ -0,0 +1,328 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/interrupt.h>
+
+#include "./common.h"
+#include "./mod.h"
+
+#define usbhs_priv_to_modinfo(priv) (&priv->mod_info)
+#define usbhs_mod_info_call(priv, func, param...)       \
+({                                              \
+        struct usbhs_mod_info *info;            \
+        info = usbhs_priv_to_modinfo(priv);     \
+        !info->func ? 0 :                       \
+         info->func(param);                     \
+})
+
+/*
+ *              autonomy
+ *
+ * these functions are used if platform doesn't have external phy.
+ *  -> there is no "notify_hotplug" callback from platform
+ *  -> call "notify_hotplug" by itself
+ *  -> use own interrupt to connect/disconnect
+ *  -> it mean module clock is always ON
+ *             ~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+static int usbhsm_autonomy_get_vbus(struct platform_device *pdev)
+{
+        struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
+
+        return  VBSTS & usbhs_read(priv, INTSTS0);
+}
+
+static int usbhsm_autonomy_irq_vbus(struct usbhs_priv *priv,
+                                    struct usbhs_irq_state *irq_state)
+{
+        struct platform_device *pdev = usbhs_priv_to_pdev(priv);
+
+        return usbhsc_drvcllbck_notify_hotplug(pdev);
+}
+
+void usbhs_mod_autonomy_mode(struct usbhs_priv *priv)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        info->irq_vbus          = usbhsm_autonomy_irq_vbus;
+        priv->pfunc->get_vbus   = usbhsm_autonomy_get_vbus;
+
+        usbhs_irq_callback_update(priv, NULL);
+}
+
+/*
+ *              host / gadget functions
+ *
+ * renesas_usbhs host/gadget can register itself by below functions.
+ * these functions are called when probe
+ *
+ */
+void usbhs_mod_register(struct usbhs_priv *priv, struct usbhs_mod *mod, int id)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        info->mod[id]   = mod;
+        mod->priv       = priv;
+}
+
+struct usbhs_mod *usbhs_mod_get(struct usbhs_priv *priv, int id)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+        struct usbhs_mod *ret = NULL;
+
+        switch (id) {
+        case USBHS_HOST:
+        case USBHS_GADGET:
+                ret = info->mod[id];
+                break;
+        }
+
+        return ret;
+}
+
+int usbhs_mod_is_host(struct usbhs_priv *priv, struct usbhs_mod *mod)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        if (!mod)
+                return -EINVAL;
+
+        return info->mod[USBHS_HOST] == mod;
+}
+
+struct usbhs_mod *usbhs_mod_get_current(struct usbhs_priv *priv)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        return info->curt;
+}
+
+int usbhs_mod_change(struct usbhs_priv *priv, int id)
+{
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+        struct usbhs_mod *mod = NULL;
+        int ret = 0;
+
+        /* id < 0 mean no current */
+        switch (id) {
+        case USBHS_HOST:
+        case USBHS_GADGET:
+                mod = info->mod[id];
+                break;
+        default:
+                ret = -EINVAL;
+        }
+        info->curt = mod;
+
+        return ret;
+}
+
+static irqreturn_t usbhs_interrupt(int irq, void *data);
+int usbhs_mod_probe(struct usbhs_priv *priv)
+{
+        struct device *dev = usbhs_priv_to_dev(priv);
+        int ret;
+
+        /*
+         * install host/gadget driver
+         */
+        ret = usbhs_mod_gadget_probe(priv);
+        if (ret < 0)
+                return ret;
+
+        /* irq settings */
+        ret = request_irq(priv->irq, usbhs_interrupt,
+                          IRQF_DISABLED, dev_name(dev), priv);
+        if (ret) {
+                dev_err(dev, "irq request err\n");
+                goto mod_init_gadget_err;
+        }
+
+        return ret;
+
+mod_init_gadget_err:
+        usbhs_mod_gadget_remove(priv);
+
+        return ret;
+}
+
+void usbhs_mod_remove(struct usbhs_priv *priv)
+{
+        usbhs_mod_gadget_remove(priv);
+        free_irq(priv->irq, priv);
+}
+
+/*
+ *              status functions
+ */
+int usbhs_status_get_usb_speed(struct usbhs_irq_state *irq_state)
+{
+        switch (irq_state->dvstctr & RHST) {
+        case RHST_LOW_SPEED:
+                return USB_SPEED_LOW;
+        case RHST_FULL_SPEED:
+                return USB_SPEED_FULL;
+        case RHST_HIGH_SPEED:
+                return USB_SPEED_HIGH;
+        }
+
+        return USB_SPEED_UNKNOWN;
+}
+
+int usbhs_status_get_device_state(struct usbhs_irq_state *irq_state)
+{
+        int state = irq_state->intsts0 & DVSQ_MASK;
+
+        switch (state) {
+        case POWER_STATE:
+        case DEFAULT_STATE:
+        case ADDRESS_STATE:
+        case CONFIGURATION_STATE:
+                return state;
+        }
+
+        return -EIO;
+}
+
+int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state)
+{
+        /*
+         * return value
+         *
+         * IDLE_SETUP_STAGE
+         * READ_DATA_STAGE
+         * READ_STATUS_STAGE
+         * WRITE_DATA_STAGE
+         * WRITE_STATUS_STAGE
+         * NODATA_STATUS_STAGE
+         * SEQUENCE_ERROR
+         */
+        return (int)irq_state->intsts0 & CTSQ_MASK;
+}
+
+static void usbhs_status_get_each_irq(struct usbhs_priv *priv,
+                                      struct usbhs_irq_state *state)
+{
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+
+        state->intsts0 = usbhs_read(priv, INTSTS0);
+        state->intsts1 = usbhs_read(priv, INTSTS1);
+
+        state->dvstctr = usbhs_read(priv, DVSTCTR);
+
+        /* mask */
+        if (mod) {
+                state->brdysts = usbhs_read(priv, BRDYSTS);
+                state->nrdysts = usbhs_read(priv, NRDYSTS);
+                state->bempsts = usbhs_read(priv, BEMPSTS);
+
+                state->bempsts &= mod->irq_bempsts;
+                state->brdysts &= mod->irq_brdysts;
+        }
+}
+
+/*
+ *              interrupt
+ */
+#define INTSTS0_MAGIC 0xF800 /* acknowledge magical interrupt sources */
+#define INTSTS1_MAGIC 0xA870 /* acknowledge magical interrupt sources */
+static irqreturn_t usbhs_interrupt(int irq, void *data)
+{
+        struct usbhs_priv *priv = data;
+        struct usbhs_irq_state irq_state;
+
+        usbhs_status_get_each_irq(priv, &irq_state);
+
+        /*
+         * clear interrupt
+         *
+         * The hardware is _very_ picky to clear interrupt bit.
+         * Especially INTSTS0_MAGIC, INTSTS1_MAGIC value.
+         *
+         * see
+         *      "Operation"
+         *       - "Control Transfer (DCP)"
+         *         - Function :: VALID bit should 0
+         */
+        usbhs_write(priv, INTSTS0, ~irq_state.intsts0 & INTSTS0_MAGIC);
+        usbhs_write(priv, INTSTS1, ~irq_state.intsts1 & INTSTS1_MAGIC);
+
+        usbhs_write(priv, BRDYSTS, 0);
+        usbhs_write(priv, NRDYSTS, 0);
+        usbhs_write(priv, BEMPSTS, 0);
+
+        /*
+         * call irq callback functions
+         * see also
+         *      usbhs_irq_setting_update
+         */
+        if (irq_state.intsts0 & VBINT)
+                usbhs_mod_info_call(priv, irq_vbus, priv, &irq_state);
+
+        if (irq_state.intsts0 & DVST)
+                usbhs_mod_call(priv, irq_dev_state, priv, &irq_state);
+
+        if (irq_state.intsts0 & CTRT)
+                usbhs_mod_call(priv, irq_ctrl_stage, priv, &irq_state);
+
+        if (irq_state.intsts0 & BEMP)
+                usbhs_mod_call(priv, irq_empty, priv, &irq_state);
+
+        if (irq_state.intsts0 & BRDY)
+                usbhs_mod_call(priv, irq_ready, priv, &irq_state);
+
+        return IRQ_HANDLED;
+}
+
+void usbhs_irq_callback_update(struct usbhs_priv *priv, struct usbhs_mod *mod)
+{
+        u16 intenb0 = 0;
+        struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
+
+        usbhs_write(priv, INTENB0, 0);
+
+        usbhs_write(priv, BEMPENB, 0);
+        usbhs_write(priv, BRDYENB, 0);
+
+        /*
+         * see also
+         *      usbhs_interrupt
+         */
+
+        /*
+         * it don't enable DVSE (intenb0) here
+         * but "mod->irq_dev_state" will be called.
+         */
+        if (info->irq_vbus)
+                intenb0 |= VBSE;
+
+        if (mod) {
+                if (mod->irq_ctrl_stage)
+                        intenb0 |= CTRE;
+
+                if (mod->irq_empty && mod->irq_bempsts) {
+                        usbhs_write(priv, BEMPENB, mod->irq_bempsts);
+                        intenb0 |= BEMPE;
+                }
+
+                if (mod->irq_ready && mod->irq_brdysts) {
+                        usbhs_write(priv, BRDYENB, mod->irq_brdysts);
+                        intenb0 |= BRDYE;
+                }
+        }
+
+        usbhs_write(priv, INTENB0, intenb0);
+}
diff --git a/drivers/usb/renesas_usbhs/mod.h b/drivers/usb/renesas_usbhs/mod.h
new file mode 100644
index 000000000000..5c845a28a21c
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/mod.h
@@ -0,0 +1,137 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#ifndef RENESAS_USB_MOD_H
+#define RENESAS_USB_MOD_H
+
+#include <linux/spinlock.h>
+#include <linux/usb/renesas_usbhs.h>
+#include "./common.h"
+
+/*
+ *      struct
+ */
+struct usbhs_irq_state {
+        u16 intsts0;
+        u16 intsts1;
+        u16 brdysts;
+        u16 nrdysts;
+        u16 bempsts;
+        u16 dvstctr;
+};
+
+struct usbhs_mod {
+        char *name;
+
+        /*
+         * entry point from common.c
+         */
+        int (*start)(struct usbhs_priv *priv);
+        int (*stop)(struct usbhs_priv *priv);
+
+        /* INTSTS0 :: DVST (DVSQ) */
+        int (*irq_dev_state)(struct usbhs_priv *priv,
+                             struct usbhs_irq_state *irq_state);
+
+        /* INTSTS0 :: CTRT (CTSQ) */
+        int (*irq_ctrl_stage)(struct usbhs_priv *priv,
+                              struct usbhs_irq_state *irq_state);
+
+        /* INTSTS0 :: BEMP */
+        /* BEMPSTS */
+        int (*irq_empty)(struct usbhs_priv *priv,
+                         struct usbhs_irq_state *irq_state);
+        u16 irq_bempsts;
+
+        /* INTSTS0 :: BRDY */
+        /* BRDYSTS */
+        int (*irq_ready)(struct usbhs_priv *priv,
+                         struct usbhs_irq_state *irq_state);
+        u16 irq_brdysts;
+
+        struct usbhs_priv *priv;
+};
+
+struct usbhs_mod_info {
+        struct usbhs_mod *mod[USBHS_MAX];
+        struct usbhs_mod *curt; /* current mod */
+
+        /*
+         * INTSTS0 :: VBINT
+         *
+         * This function will be used as autonomy mode
+         * when platform cannot call notify_hotplug.
+         *
+         * This callback cannot be member of "struct usbhs_mod"
+         * because it will be used even though
+         * host/gadget has not been selected.
+         */
+        int (*irq_vbus)(struct usbhs_priv *priv,
+                        struct usbhs_irq_state *irq_state);
+};
+
+/*
+ *              for host/gadget module
+ */
+struct usbhs_mod *usbhs_mod_get(struct usbhs_priv *priv, int id);
+struct usbhs_mod *usbhs_mod_get_current(struct usbhs_priv *priv);
+void usbhs_mod_register(struct usbhs_priv *priv, struct usbhs_mod *usb, int id);
+int usbhs_mod_is_host(struct usbhs_priv *priv, struct usbhs_mod *mod);
+int usbhs_mod_change(struct usbhs_priv *priv, int id);
+int usbhs_mod_probe(struct usbhs_priv *priv);
+void usbhs_mod_remove(struct usbhs_priv *priv);
+
+void usbhs_mod_autonomy_mode(struct usbhs_priv *priv);
+
+/*
+ *              status functions
+ */
+int usbhs_status_get_usb_speed(struct usbhs_irq_state *irq_state);
+int usbhs_status_get_device_state(struct usbhs_irq_state *irq_state);
+int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state);
+
+/*
+ *              callback functions
+ */
+void usbhs_irq_callback_update(struct usbhs_priv *priv, struct usbhs_mod *mod);
+
+
+#define usbhs_mod_call(priv, func, param...)            \
+        ({                                              \
+                struct usbhs_mod *mod;                  \
+                mod = usbhs_mod_get_current(priv);      \
+                !mod            ? -ENODEV :             \
+                !mod->func      ? 0 :                   \
+                 mod->func(param);                      \
+        })
+
+/*
+ * gadget control
+ */
+#ifdef CONFIG_USB_RENESAS_USBHS_UDC
+extern int __devinit usbhs_mod_gadget_probe(struct usbhs_priv *priv);
+extern void __devexit usbhs_mod_gadget_remove(struct usbhs_priv *priv);
+#else
+static inline int usbhs_mod_gadget_probe(struct usbhs_priv *priv)
+{
+        return 0;
+}
+static inline void usbhs_mod_gadget_remove(struct usbhs_priv *priv)
+{
+}
+#endif
+
+#endif /* RENESAS_USB_MOD_H */
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
new file mode 100644
index 000000000000..206cfabc9286
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -0,0 +1,1384 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include "common.h"
+
+/*
+ *              struct
+ */
+struct usbhsg_request {
+        struct usb_request      req;
+        struct list_head        node;
+};
+
+#define EP_NAME_SIZE 8
+struct usbhsg_gpriv;
+struct usbhsg_pipe_handle;
+struct usbhsg_uep {
+        struct usb_ep            ep;
+        struct usbhs_pipe       *pipe;
+        struct list_head         list;
+
+        char ep_name[EP_NAME_SIZE];
+
+        struct usbhsg_gpriv *gpriv;
+        struct usbhsg_pipe_handle *handler;
+};
+
+struct usbhsg_gpriv {
+        struct usb_gadget        gadget;
+        struct usbhs_mod         mod;
+
+        struct usbhsg_uep       *uep;
+        int                      uep_size;
+
+        struct usb_gadget_driver        *driver;
+
+        u32     status;
+#define USBHSG_STATUS_STARTED           (1 << 0)
+#define USBHSG_STATUS_REGISTERD         (1 << 1)
+#define USBHSG_STATUS_WEDGE             (1 << 2)
+};
+
+struct usbhsg_pipe_handle {
+        int (*prepare)(struct usbhsg_uep *uep, struct usbhsg_request *ureq);
+        int (*try_run)(struct usbhsg_uep *uep, struct usbhsg_request *ureq);
+        void (*irq_mask)(struct usbhsg_uep *uep, int enable);
+};
+
+struct usbhsg_recip_handle {
+        char *name;
+        int (*device)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
+                      struct usb_ctrlrequest *ctrl);
+        int (*interface)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
+                         struct usb_ctrlrequest *ctrl);
+        int (*endpoint)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
+                        struct usb_ctrlrequest *ctrl);
+};
+
+/*
+ *              macro
+ */
+#define usbhsg_priv_to_gpriv(priv)                      \
+        container_of(                                   \
+                usbhs_mod_get(priv, USBHS_GADGET),      \
+                struct usbhsg_gpriv, mod)
+
+#define __usbhsg_for_each_uep(start, pos, g, i) \
+        for (i = start, pos = (g)->uep;         \
+             i < (g)->uep_size;                 \
+             i++, pos = (g)->uep + i)
+
+#define usbhsg_for_each_uep(pos, gpriv, i)      \
+        __usbhsg_for_each_uep(1, pos, gpriv, i)
+
+#define usbhsg_for_each_uep_with_dcp(pos, gpriv, i)     \
+        __usbhsg_for_each_uep(0, pos, gpriv, i)
+
+#define usbhsg_gadget_to_gpriv(g)\
+        container_of(g, struct usbhsg_gpriv, gadget)
+
+#define usbhsg_req_to_ureq(r)\
+        container_of(r, struct usbhsg_request, req)
+
+#define usbhsg_ep_to_uep(e)             container_of(e, struct usbhsg_uep, ep)
+#define usbhsg_gpriv_to_lock(gp)        usbhs_priv_to_lock((gp)->mod.priv)
+#define usbhsg_gpriv_to_dev(gp)         usbhs_priv_to_dev((gp)->mod.priv)
+#define usbhsg_gpriv_to_priv(gp)        ((gp)->mod.priv)
+#define usbhsg_gpriv_to_dcp(gp)         ((gp)->uep)
+#define usbhsg_gpriv_to_nth_uep(gp, i)  ((gp)->uep + i)
+#define usbhsg_uep_to_gpriv(u)          ((u)->gpriv)
+#define usbhsg_uep_to_pipe(u)           ((u)->pipe)
+#define usbhsg_pipe_to_uep(p)           ((p)->mod_private)
+#define usbhsg_is_dcp(u)                ((u) == usbhsg_gpriv_to_dcp((u)->gpriv))
+
+#define usbhsg_is_not_connected(gp) ((gp)->gadget.speed == USB_SPEED_UNKNOWN)
+
+/* status */
+#define usbhsg_status_init(gp)   do {(gp)->status = 0; } while (0)
+#define usbhsg_status_set(gp, b) (gp->status |=  b)
+#define usbhsg_status_clr(gp, b) (gp->status &= ~b)
+#define usbhsg_status_has(gp, b) (gp->status &   b)
+
+/*
+ *              usbhsg_trylock
+ *
+ * This driver don't use spin_try_lock
+ * to avoid warning of CONFIG_DEBUG_SPINLOCK
+ */
+static spinlock_t *usbhsg_trylock(struct usbhsg_gpriv *gpriv,
+                                  unsigned long *flags)
+{
+        spinlock_t *lock = usbhsg_gpriv_to_lock(gpriv);
+
+        /* check spin lock status
+         * to avoid deadlock/nest */
+        if (spin_is_locked(lock))
+                return NULL;
+
+        spin_lock_irqsave(lock, *flags);
+
+        return lock;
+}
+
+static void usbhsg_unlock(spinlock_t *lock, unsigned long *flags)
+{
+        if (!lock)
+                return;
+
+        spin_unlock_irqrestore(lock, *flags);
+}
+
+/*
+ *              list push/pop
+ */
+static void usbhsg_queue_push(struct usbhsg_uep *uep,
+                              struct usbhsg_request *ureq)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+
+        /*
+         *********  assume under spin lock  *********
+         */
+        list_del_init(&ureq->node);
+        list_add_tail(&ureq->node, &uep->list);
+        ureq->req.actual = 0;
+        ureq->req.status = -EINPROGRESS;
+
+        dev_dbg(dev, "pipe %d : queue push (%d)\n",
+                usbhs_pipe_number(pipe),
+                ureq->req.length);
+}
+
+static struct usbhsg_request *usbhsg_queue_get(struct usbhsg_uep *uep)
+{
+        /*
+         *********  assume under spin lock  *********
+         */
+        if (list_empty(&uep->list))
+                return NULL;
+
+        return list_entry(uep->list.next, struct usbhsg_request, node);
+}
+
+#define usbhsg_queue_prepare(uep) __usbhsg_queue_handler(uep, 1);
+#define usbhsg_queue_handle(uep)  __usbhsg_queue_handler(uep, 0);
+static int __usbhsg_queue_handler(struct usbhsg_uep *uep, int prepare)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        struct usbhsg_request *ureq;
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret = 0;
+
+        if (!uep->handler) {
+                dev_err(dev, "no handler function\n");
+                return -EIO;
+        }
+
+        /*
+         * CAUTION [*queue handler*]
+         *
+         * This function will be called for start/restart queue operation.
+         * OTOH the most much worry for USB driver is spinlock nest.
+         * Specially it are
+         *   - usb_ep_ops  :: queue
+         *   - usb_request :: complete
+         *
+         * But the caller of this function need not care about spinlock.
+         * This function is using usbhsg_trylock for it.
+         * if "is_locked" is 1, this mean this function lock it.
+         * but if it is 0, this mean it is already under spin lock.
+         * see also
+         *   CAUTION [*endpoint queue*]
+         *   CAUTION [*request complete*]
+         */
+
+        /******************  spin try lock *******************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        ureq = usbhsg_queue_get(uep);
+        if (ureq) {
+                if (prepare)
+                        ret = uep->handler->prepare(uep, ureq);
+                else
+                        ret = uep->handler->try_run(uep, ureq);
+        }
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return ret;
+}
+
+static void usbhsg_queue_pop(struct usbhsg_uep *uep,
+                             struct usbhsg_request *ureq,
+                             int status)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        /*
+         * CAUTION [*request complete*]
+         *
+         * There is a possibility not to be called in correct order
+         * if "complete" is called without spinlock.
+         *
+         * So, this function assume it is under spinlock,
+         * and call usb_request :: complete.
+         *
+         * But this "complete" will push next usb_request.
+         * It mean "usb_ep_ops :: queue" which is using spinlock is called
+         * under spinlock.
+         *
+         * To avoid dead-lock, this driver is using usbhsg_trylock.
+         *   CAUTION [*endpoint queue*]
+         *   CAUTION [*queue handler*]
+         */
+
+        dev_dbg(dev, "pipe %d : queue pop\n", usbhs_pipe_number(pipe));
+
+        list_del_init(&ureq->node);
+
+        ureq->req.status = status;
+        ureq->req.complete(&uep->ep, &ureq->req);
+
+        /* more request ? */
+        if (0 == status)
+                usbhsg_queue_prepare(uep);
+}
+
+/*
+ *              irq enable/disable function
+ */
+#define usbhsg_irq_callback_ctrl(uep, status, enable)                   \
+        ({                                                              \
+                struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);  \
+                struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);      \
+                struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);  \
+                struct usbhs_mod *mod = usbhs_mod_get_current(priv);    \
+                if (!mod)                                               \
+                        return;                                         \
+                if (enable)                                             \
+                        mod->irq_##status |= (1 << usbhs_pipe_number(pipe)); \
+                else                                                    \
+                        mod->irq_##status &= ~(1 << usbhs_pipe_number(pipe)); \
+                usbhs_irq_callback_update(priv, mod);                   \
+        })
+
+static void usbhsg_irq_empty_ctrl(struct usbhsg_uep *uep, int enable)
+{
+        usbhsg_irq_callback_ctrl(uep, bempsts, enable);
+}
+
+static void usbhsg_irq_ready_ctrl(struct usbhsg_uep *uep, int enable)
+{
+        usbhsg_irq_callback_ctrl(uep, brdysts, enable);
+}
+
+/*
+ *              handler function
+ */
+static int usbhsg_try_run_ctrl_stage_end(struct usbhsg_uep *uep,
+                                         struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        usbhs_dcp_control_transfer_done(pipe);
+        usbhsg_queue_pop(uep, ureq, 0);
+
+        return 0;
+}
+
+static int usbhsg_try_run_send_packet(struct usbhsg_uep *uep,
+                                      struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct usb_request *req = &ureq->req;
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        void *buf;
+        int remainder, send;
+        int is_done = 0;
+        int enable;
+        int maxp;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        maxp            = usbhs_pipe_get_maxpacket(pipe);
+        buf             = req->buf    + req->actual;
+        remainder       = req->length - req->actual;
+
+        send = usbhs_fifo_write(pipe, buf, remainder);
+
+        /*
+         * send < 0 : pipe busy
+         * send = 0 : send zero packet
+         * send > 0 : send data
+         *
+         * send <= max_packet
+         */
+        if (send > 0)
+                req->actual += send;
+
+        /* send all packet ? */
+        if (send < remainder)
+                is_done = 0;            /* there are remainder data */
+        else if (send < maxp)
+                is_done = 1;            /* short packet */
+        else
+                is_done = !req->zero;   /* send zero packet ? */
+
+        dev_dbg(dev, "  send %d (%d/ %d/ %d/ %d)\n",
+                usbhs_pipe_number(pipe),
+                remainder, send, is_done, req->zero);
+
+        /*
+         * enable interrupt and send again in irq handler
+         * if it still have remainder data which should be sent.
+         */
+        enable = !is_done;
+        uep->handler->irq_mask(uep, enable);
+
+        /*
+         * usbhs_fifo_enable execute
+         *  - after callback_update,
+         *  - before queue_pop / stage_end
+         */
+        usbhs_fifo_enable(pipe);
+
+        /*
+         * all data were sent ?
+         */
+        if (is_done) {
+                /* it care below call in
+                   "function mode" */
+                if (usbhsg_is_dcp(uep))
+                        usbhs_dcp_control_transfer_done(pipe);
+
+                usbhsg_queue_pop(uep, ureq, 0);
+        }
+
+        return 0;
+}
+
+static int usbhsg_prepare_send_packet(struct usbhsg_uep *uep,
+                                      struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        usbhs_fifo_prepare_write(pipe);
+        usbhsg_try_run_send_packet(uep, ureq);
+
+        return 0;
+}
+
+static int usbhsg_try_run_receive_packet(struct usbhsg_uep *uep,
+                                         struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct usb_request *req = &ureq->req;
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        void *buf;
+        int maxp;
+        int remainder, recv;
+        int is_done = 0;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        maxp            = usbhs_pipe_get_maxpacket(pipe);
+        buf             = req->buf    + req->actual;
+        remainder       = req->length - req->actual;
+
+        recv = usbhs_fifo_read(pipe, buf, remainder);
+        /*
+         * recv < 0  : pipe busy
+         * recv >= 0 : receive data
+         *
+         * recv <= max_packet
+         */
+        if (recv < 0)
+                return -EBUSY;
+
+        /* update parameters */
+        req->actual += recv;
+
+        if ((recv == remainder) ||      /* receive all data */
+            (recv < maxp))              /* short packet */
+                is_done = 1;
+
+        dev_dbg(dev, "  recv %d (%d/ %d/ %d/ %d)\n",
+                usbhs_pipe_number(pipe),
+                remainder, recv, is_done, req->zero);
+
+        /* read all data ? */
+        if (is_done) {
+                int disable = 0;
+
+                uep->handler->irq_mask(uep, disable);
+                usbhs_fifo_disable(pipe);
+                usbhsg_queue_pop(uep, ureq, 0);
+        }
+
+        return 0;
+}
+
+static int usbhsg_prepare_receive_packet(struct usbhsg_uep *uep,
+                                         struct usbhsg_request *ureq)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        int enable = 1;
+        int ret;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        ret = usbhs_fifo_prepare_read(pipe);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * data will be read in interrupt handler
+         */
+        uep->handler->irq_mask(uep, enable);
+
+        return ret;
+}
+
+static struct usbhsg_pipe_handle usbhsg_handler_send_by_empty = {
+        .prepare        = usbhsg_prepare_send_packet,
+        .try_run        = usbhsg_try_run_send_packet,
+        .irq_mask       = usbhsg_irq_empty_ctrl,
+};
+
+static struct usbhsg_pipe_handle usbhsg_handler_send_by_ready = {
+        .prepare        = usbhsg_prepare_send_packet,
+        .try_run        = usbhsg_try_run_send_packet,
+        .irq_mask       = usbhsg_irq_ready_ctrl,
+};
+
+static struct usbhsg_pipe_handle usbhsg_handler_recv_by_ready = {
+        .prepare        = usbhsg_prepare_receive_packet,
+        .try_run        = usbhsg_try_run_receive_packet,
+        .irq_mask       = usbhsg_irq_ready_ctrl,
+};
+
+static struct usbhsg_pipe_handle usbhsg_handler_ctrl_stage_end = {
+        .prepare        = usbhsg_try_run_ctrl_stage_end,
+        .try_run        = usbhsg_try_run_ctrl_stage_end,
+};
+
+/*
+ * DCP pipe can NOT use "ready interrupt" for "send"
+ * it should use "empty" interrupt.
+ * see
+ *   "Operation" - "Interrupt Function" - "BRDY Interrupt"
+ *
+ * on the other hand, normal pipe can use "ready interrupt" for "send"
+ * even though it is single/double buffer
+ */
+#define usbhsg_handler_send_ctrl        usbhsg_handler_send_by_empty
+#define usbhsg_handler_recv_ctrl        usbhsg_handler_recv_by_ready
+
+#define usbhsg_handler_send_packet      usbhsg_handler_send_by_ready
+#define usbhsg_handler_recv_packet      usbhsg_handler_recv_by_ready
+
+/*
+ *              USB_TYPE_STANDARD / clear feature functions
+ */
+static int usbhsg_recip_handler_std_control_done(struct usbhs_priv *priv,
+                                                 struct usbhsg_uep *uep,
+                                                 struct usb_ctrlrequest *ctrl)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
+
+        usbhs_dcp_control_transfer_done(pipe);
+
+        return 0;
+}
+
+static int usbhsg_recip_handler_std_clear_endpoint(struct usbhs_priv *priv,
+                                                   struct usbhsg_uep *uep,
+                                                   struct usb_ctrlrequest *ctrl)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+
+        if (!usbhsg_status_has(gpriv, USBHSG_STATUS_WEDGE)) {
+                usbhs_fifo_disable(pipe);
+                usbhs_pipe_clear_sequence(pipe);
+                usbhs_fifo_enable(pipe);
+        }
+
+        usbhsg_recip_handler_std_control_done(priv, uep, ctrl);
+
+        usbhsg_queue_prepare(uep);
+
+        return 0;
+}
+
+struct usbhsg_recip_handle req_clear_feature = {
+        .name           = "clear feature",
+        .device         = usbhsg_recip_handler_std_control_done,
+        .interface      = usbhsg_recip_handler_std_control_done,
+        .endpoint       = usbhsg_recip_handler_std_clear_endpoint,
+};
+
+/*
+ *              USB_TYPE handler
+ */
+static int usbhsg_recip_run_handle(struct usbhs_priv *priv,
+                                   struct usbhsg_recip_handle *handler,
+                                   struct usb_ctrlrequest *ctrl)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        struct usbhsg_uep *uep;
+        int recip = ctrl->bRequestType & USB_RECIP_MASK;
+        int nth = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
+        int ret;
+        int (*func)(struct usbhs_priv *priv, struct usbhsg_uep *uep,
+                    struct usb_ctrlrequest *ctrl);
+        char *msg;
+
+        uep = usbhsg_gpriv_to_nth_uep(gpriv, nth);
+        if (!usbhsg_uep_to_pipe(uep)) {
+                dev_err(dev, "wrong recip request\n");
+                return -EINVAL;
+        }
+
+        switch (recip) {
+        case USB_RECIP_DEVICE:
+                msg     = "DEVICE";
+                func    = handler->device;
+                break;
+        case USB_RECIP_INTERFACE:
+                msg     = "INTERFACE";
+                func    = handler->interface;
+                break;
+        case USB_RECIP_ENDPOINT:
+                msg     = "ENDPOINT";
+                func    = handler->endpoint;
+                break;
+        default:
+                dev_warn(dev, "unsupported RECIP(%d)\n", recip);
+                func = NULL;
+                ret = -EINVAL;
+        }
+
+        if (func) {
+                dev_dbg(dev, "%s (pipe %d :%s)\n", handler->name, nth, msg);
+                ret = func(priv, uep, ctrl);
+        }
+
+        return ret;
+}
+
+/*
+ *              irq functions
+ *
+ * it will be called from usbhs_interrupt
+ */
+static int usbhsg_irq_dev_state(struct usbhs_priv *priv,
+                                struct usbhs_irq_state *irq_state)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+
+        gpriv->gadget.speed = usbhs_status_get_usb_speed(irq_state);
+
+        dev_dbg(dev, "state = %x : speed : %d\n",
+                usbhs_status_get_device_state(irq_state),
+                gpriv->gadget.speed);
+
+        return 0;
+}
+
+static int usbhsg_irq_ctrl_stage(struct usbhs_priv *priv,
+                                 struct usbhs_irq_state *irq_state)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        struct usb_ctrlrequest ctrl;
+        struct usbhsg_recip_handle *recip_handler = NULL;
+        int stage = usbhs_status_get_ctrl_stage(irq_state);
+        int ret = 0;
+
+        dev_dbg(dev, "stage = %d\n", stage);
+
+        /*
+         * see Manual
+         *
+         *  "Operation"
+         *  - "Interrupt Function"
+         *    - "Control Transfer Stage Transition Interrupt"
+         *      - Fig. "Control Transfer Stage Transitions"
+         */
+
+        switch (stage) {
+        case READ_DATA_STAGE:
+                dcp->handler = &usbhsg_handler_send_ctrl;
+                break;
+        case WRITE_DATA_STAGE:
+                dcp->handler = &usbhsg_handler_recv_ctrl;
+                break;
+        case NODATA_STATUS_STAGE:
+                dcp->handler = &usbhsg_handler_ctrl_stage_end;
+                break;
+        default:
+                return ret;
+        }
+
+        /*
+         * get usb request
+         */
+        usbhs_usbreq_get_val(priv, &ctrl);
+
+        switch (ctrl.bRequestType & USB_TYPE_MASK) {
+        case USB_TYPE_STANDARD:
+                switch (ctrl.bRequest) {
+                case USB_REQ_CLEAR_FEATURE:
+                        recip_handler = &req_clear_feature;
+                        break;
+                }
+        }
+
+        /*
+         * setup stage / run recip
+         */
+        if (recip_handler)
+                ret = usbhsg_recip_run_handle(priv, recip_handler, &ctrl);
+        else
+                ret = gpriv->driver->setup(&gpriv->gadget, &ctrl);
+
+        if (ret < 0)
+                usbhs_fifo_stall(pipe);
+
+        return ret;
+}
+
+static int usbhsg_irq_empty(struct usbhs_priv *priv,
+                            struct usbhs_irq_state *irq_state)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *uep;
+        struct usbhs_pipe *pipe;
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        int i, ret;
+
+        if (!irq_state->bempsts) {
+                dev_err(dev, "debug %s !!\n", __func__);
+                return -EIO;
+        }
+
+        dev_dbg(dev, "irq empty [0x%04x]\n", irq_state->bempsts);
+
+        /*
+         * search interrupted "pipe"
+         * not "uep".
+         */
+        usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+                if (!(irq_state->bempsts & (1 << i)))
+                        continue;
+
+                uep     = usbhsg_pipe_to_uep(pipe);
+                ret     = usbhsg_queue_handle(uep);
+                if (ret < 0)
+                        dev_err(dev, "send error %d : %d\n", i, ret);
+        }
+
+        return 0;
+}
+
+static int usbhsg_irq_ready(struct usbhs_priv *priv,
+                            struct usbhs_irq_state *irq_state)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *uep;
+        struct usbhs_pipe *pipe;
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        int i, ret;
+
+        if (!irq_state->brdysts) {
+                dev_err(dev, "debug %s !!\n", __func__);
+                return -EIO;
+        }
+
+        dev_dbg(dev, "irq ready [0x%04x]\n", irq_state->brdysts);
+
+        /*
+         * search interrupted "pipe"
+         * not "uep".
+         */
+        usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+                if (!(irq_state->brdysts & (1 << i)))
+                        continue;
+
+                uep     = usbhsg_pipe_to_uep(pipe);
+                ret     = usbhsg_queue_handle(uep);
+                if (ret < 0)
+                        dev_err(dev, "receive error %d : %d\n", i, ret);
+        }
+
+        return 0;
+}
+
+/*
+ *
+ *              usb_dcp_ops
+ *
+ */
+static int usbhsg_dcp_enable(struct usbhsg_uep *uep)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
+        struct usbhs_pipe *pipe;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        pipe = usbhs_dcp_malloc(priv);
+        if (!pipe)
+                return -EIO;
+
+        uep->pipe               = pipe;
+        uep->pipe->mod_private  = uep;
+        INIT_LIST_HEAD(&uep->list);
+
+        return 0;
+}
+
+#define usbhsg_dcp_disable usbhsg_pipe_disable
+static int usbhsg_pipe_disable(struct usbhsg_uep *uep)
+{
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct usbhsg_request *ureq;
+        int disable = 0;
+
+        /*
+         *********  assume under spin lock  *********
+         */
+
+        usbhs_fifo_disable(pipe);
+
+        /*
+         * disable pipe irq
+         */
+        usbhsg_irq_empty_ctrl(uep, disable);
+        usbhsg_irq_ready_ctrl(uep, disable);
+
+        while (1) {
+                ureq = usbhsg_queue_get(uep);
+                if (!ureq)
+                        break;
+
+                usbhsg_queue_pop(uep, ureq, -ECONNRESET);
+        }
+
+        return 0;
+}
+
+static void usbhsg_uep_init(struct usbhsg_gpriv *gpriv)
+{
+        int i;
+        struct usbhsg_uep *uep;
+
+        usbhsg_for_each_uep_with_dcp(uep, gpriv, i)
+                uep->pipe = NULL;
+}
+
+/*
+ *
+ *              usb_ep_ops
+ *
+ */
+static int usbhsg_ep_enable(struct usb_ep *ep,
+                         const struct usb_endpoint_descriptor *desc)
+{
+        struct usbhsg_uep *uep   = usbhsg_ep_to_uep(ep);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
+        struct usbhs_pipe *pipe;
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret = -EIO;
+
+        /*
+         * if it already have pipe,
+         * nothing to do
+         */
+        if (uep->pipe)
+                return 0;
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        pipe = usbhs_pipe_malloc(priv, desc);
+        if (pipe) {
+                uep->pipe               = pipe;
+                pipe->mod_private       = uep;
+                INIT_LIST_HEAD(&uep->list);
+
+                if (usb_endpoint_dir_in(desc))
+                        uep->handler = &usbhsg_handler_send_packet;
+                else
+                        uep->handler = &usbhsg_handler_recv_packet;
+
+                ret = 0;
+        }
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return ret;
+}
+
+static int usbhsg_ep_disable(struct usb_ep *ep)
+{
+        struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret;
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        ret = usbhsg_pipe_disable(uep);
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return ret;
+}
+
+static struct usb_request *usbhsg_ep_alloc_request(struct usb_ep *ep,
+                                                   gfp_t gfp_flags)
+{
+        struct usbhsg_request *ureq;
+
+        ureq = kzalloc(sizeof *ureq, gfp_flags);
+        if (!ureq)
+                return NULL;
+
+        INIT_LIST_HEAD(&ureq->node);
+        return &ureq->req;
+}
+
+static void usbhsg_ep_free_request(struct usb_ep *ep,
+                                   struct usb_request *req)
+{
+        struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
+
+        WARN_ON(!list_empty(&ureq->node));
+        kfree(ureq);
+}
+
+static int usbhsg_ep_queue(struct usb_ep *ep, struct usb_request *req,
+                          gfp_t gfp_flags)
+{
+        struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret = 0;
+
+        /*
+         * CAUTION [*endpoint queue*]
+         *
+         * This function will be called from usb_request :: complete
+         * or usb driver timing.
+         * If this function is called from usb_request :: complete,
+         * it is already under spinlock on this driver.
+         * but it is called frm usb driver, this function should call spinlock.
+         *
+         * This function is using usbshg_trylock to solve this issue.
+         * if "is_locked" is 1, this mean this function lock it.
+         * but if it is 0, this mean it is already under spin lock.
+         * see also
+         *   CAUTION [*queue handler*]
+         *   CAUTION [*request complete*]
+         */
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        /* param check */
+        if (usbhsg_is_not_connected(gpriv)      ||
+            unlikely(!gpriv->driver)            ||
+            unlikely(!pipe))
+                ret = -ESHUTDOWN;
+        else
+                usbhsg_queue_push(uep, ureq);
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        usbhsg_queue_prepare(uep);
+
+        return ret;
+}
+
+static int usbhsg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
+{
+        struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
+        struct usbhsg_request *ureq = usbhsg_req_to_ureq(req);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        spinlock_t *lock;
+        unsigned long flags;
+
+        /*
+         * see
+         *   CAUTION [*queue handler*]
+         *   CAUTION [*endpoint queue*]
+         *   CAUTION [*request complete*]
+         */
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        usbhsg_queue_pop(uep, ureq, -ECONNRESET);
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return 0;
+}
+
+static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge)
+{
+        struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep);
+        struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep);
+        struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep);
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+        spinlock_t *lock;
+        unsigned long flags;
+        int ret = -EAGAIN;
+
+        /*
+         * see
+         *   CAUTION [*queue handler*]
+         *   CAUTION [*endpoint queue*]
+         *   CAUTION [*request complete*]
+         */
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+        if (!usbhsg_queue_get(uep)) {
+
+                dev_dbg(dev, "set halt %d (pipe %d)\n",
+                        halt, usbhs_pipe_number(pipe));
+
+                if (halt)
+                        usbhs_fifo_stall(pipe);
+                else
+                        usbhs_fifo_disable(pipe);
+
+                if (halt && wedge)
+                        usbhsg_status_set(gpriv, USBHSG_STATUS_WEDGE);
+                else
+                        usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE);
+
+                ret = 0;
+        }
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ******************/
+
+        return ret;
+}
+
+static int usbhsg_ep_set_halt(struct usb_ep *ep, int value)
+{
+        return __usbhsg_ep_set_halt_wedge(ep, value, 0);
+}
+
+static int usbhsg_ep_set_wedge(struct usb_ep *ep)
+{
+        return __usbhsg_ep_set_halt_wedge(ep, 1, 1);
+}
+
+static struct usb_ep_ops usbhsg_ep_ops = {
+        .enable         = usbhsg_ep_enable,
+        .disable        = usbhsg_ep_disable,
+
+        .alloc_request  = usbhsg_ep_alloc_request,
+        .free_request   = usbhsg_ep_free_request,
+
+        .queue          = usbhsg_ep_queue,
+        .dequeue        = usbhsg_ep_dequeue,
+
+        .set_halt       = usbhsg_ep_set_halt,
+        .set_wedge      = usbhsg_ep_set_wedge,
+};
+
+/*
+ *              usb module start/end
+ */
+static int usbhsg_try_start(struct usbhs_priv *priv, u32 status)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+        struct device *dev = usbhs_priv_to_dev(priv);
+        spinlock_t *lock;
+        unsigned long flags;
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        /*
+         * enable interrupt and systems if ready
+         */
+        usbhsg_status_set(gpriv, status);
+        if (!(usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
+              usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD)))
+                goto usbhsg_try_start_unlock;
+
+        dev_dbg(dev, "start gadget\n");
+
+        /*
+         * pipe initialize and enable DCP
+         */
+        usbhs_pipe_init(priv);
+        usbhsg_uep_init(gpriv);
+        usbhsg_dcp_enable(dcp);
+
+        /*
+         * system config enble
+         * - HI speed
+         * - function
+         * - usb module
+         */
+        usbhs_sys_hispeed_ctrl(priv, 1);
+        usbhs_sys_function_ctrl(priv, 1);
+        usbhs_sys_usb_ctrl(priv, 1);
+
+        /*
+         * enable irq callback
+         */
+        mod->irq_dev_state      = usbhsg_irq_dev_state;
+        mod->irq_ctrl_stage     = usbhsg_irq_ctrl_stage;
+        mod->irq_empty          = usbhsg_irq_empty;
+        mod->irq_ready          = usbhsg_irq_ready;
+        mod->irq_bempsts        = 0;
+        mod->irq_brdysts        = 0;
+        usbhs_irq_callback_update(priv, mod);
+
+usbhsg_try_start_unlock:
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ********************/
+
+        return 0;
+}
+
+static int usbhsg_try_stop(struct usbhs_priv *priv, u32 status)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+        struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv);
+        struct device *dev = usbhs_priv_to_dev(priv);
+        spinlock_t *lock;
+        unsigned long flags;
+
+        /********************  spin lock ********************/
+        lock = usbhsg_trylock(gpriv, &flags);
+
+        /*
+         * disable interrupt and systems if 1st try
+         */
+        usbhsg_status_clr(gpriv, status);
+        if (!usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) &&
+            !usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD))
+                goto usbhsg_try_stop_unlock;
+
+        /* disable all irq */
+        mod->irq_dev_state      = NULL;
+        mod->irq_ctrl_stage     = NULL;
+        mod->irq_empty          = NULL;
+        mod->irq_ready          = NULL;
+        mod->irq_bempsts        = 0;
+        mod->irq_brdysts        = 0;
+        usbhs_irq_callback_update(priv, mod);
+
+        usbhsg_dcp_disable(dcp);
+
+        gpriv->gadget.speed = USB_SPEED_UNKNOWN;
+
+        /* disable sys */
+        usbhs_sys_hispeed_ctrl(priv, 0);
+        usbhs_sys_function_ctrl(priv, 0);
+        usbhs_sys_usb_ctrl(priv, 0);
+
+        usbhsg_unlock(lock, &flags);
+        /********************  spin unlock ********************/
+
+        if (gpriv->driver &&
+            gpriv->driver->disconnect)
+                gpriv->driver->disconnect(&gpriv->gadget);
+
+        dev_dbg(dev, "stop gadget\n");
+
+        return 0;
+
+usbhsg_try_stop_unlock:
+        usbhsg_unlock(lock, &flags);
+
+        return 0;
+}
+
+/*
+ *
+ *              linux usb function
+ *
+ */
+struct usbhsg_gpriv *the_controller;
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                            int (*bind)(struct usb_gadget *))
+{
+        struct usbhsg_gpriv *gpriv = the_controller;
+        struct usbhs_priv *priv;
+        struct device *dev;
+        int ret;
+
+        if (!bind               ||
+            !driver             ||
+            !driver->setup      ||
+            driver->speed != USB_SPEED_HIGH)
+                return -EINVAL;
+        if (!gpriv)
+                return -ENODEV;
+        if (gpriv->driver)
+                return -EBUSY;
+
+        dev  = usbhsg_gpriv_to_dev(gpriv);
+        priv = usbhsg_gpriv_to_priv(gpriv);
+
+        /* first hook up the driver ... */
+        gpriv->driver = driver;
+        gpriv->gadget.dev.driver = &driver->driver;
+
+        ret = device_add(&gpriv->gadget.dev);
+        if (ret) {
+                dev_err(dev, "device_add error %d\n", ret);
+                goto add_fail;
+        }
+
+        ret = bind(&gpriv->gadget);
+        if (ret) {
+                dev_err(dev, "bind to driver %s error %d\n",
+                        driver->driver.name, ret);
+                goto bind_fail;
+        }
+
+        dev_dbg(dev, "bind %s\n", driver->driver.name);
+
+        return usbhsg_try_start(priv, USBHSG_STATUS_REGISTERD);
+
+bind_fail:
+        device_del(&gpriv->gadget.dev);
+add_fail:
+        gpriv->driver = NULL;
+        gpriv->gadget.dev.driver = NULL;
+
+        return ret;
+}
+EXPORT_SYMBOL(usb_gadget_probe_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct usbhsg_gpriv *gpriv = the_controller;
+        struct usbhs_priv *priv;
+        struct device *dev = usbhsg_gpriv_to_dev(gpriv);
+
+        if (!gpriv)
+                return -ENODEV;
+
+        if (!driver             ||
+            !driver->unbind     ||
+            driver != gpriv->driver)
+                return -EINVAL;
+
+        dev  = usbhsg_gpriv_to_dev(gpriv);
+        priv = usbhsg_gpriv_to_priv(gpriv);
+
+        usbhsg_try_stop(priv, USBHSG_STATUS_REGISTERD);
+        device_del(&gpriv->gadget.dev);
+        gpriv->driver = NULL;
+
+        if (driver->disconnect)
+                driver->disconnect(&gpriv->gadget);
+
+        driver->unbind(&gpriv->gadget);
+        dev_dbg(dev, "unbind %s\n", driver->driver.name);
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+/*
+ *              usb gadget ops
+ */
+static int usbhsg_get_frame(struct usb_gadget *gadget)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget);
+        struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
+
+        return usbhs_frame_get_num(priv);
+}
+
+static struct usb_gadget_ops usbhsg_gadget_ops = {
+        .get_frame              = usbhsg_get_frame,
+};
+
+static int usbhsg_start(struct usbhs_priv *priv)
+{
+        return usbhsg_try_start(priv, USBHSG_STATUS_STARTED);
+}
+
+static int usbhsg_stop(struct usbhs_priv *priv)
+{
+        return usbhsg_try_stop(priv, USBHSG_STATUS_STARTED);
+}
+
+int __devinit usbhs_mod_gadget_probe(struct usbhs_priv *priv)
+{
+        struct usbhsg_gpriv *gpriv;
+        struct usbhsg_uep *uep;
+        struct device *dev = usbhs_priv_to_dev(priv);
+        int pipe_size = usbhs_get_dparam(priv, pipe_size);
+        int i;
+
+        gpriv = kzalloc(sizeof(struct usbhsg_gpriv), GFP_KERNEL);
+        if (!gpriv) {
+                dev_err(dev, "Could not allocate gadget priv\n");
+                return -ENOMEM;
+        }
+
+        uep = kzalloc(sizeof(struct usbhsg_uep) * pipe_size, GFP_KERNEL);
+        if (!uep) {
+                dev_err(dev, "Could not allocate ep\n");
+                goto usbhs_mod_gadget_probe_err_gpriv;
+        }
+
+        /*
+         * CAUTION
+         *
+         * There is no guarantee that it is possible to access usb module here.
+         * Don't accesses to it.
+         * The accesse will be enable after "usbhsg_start"
+         */
+
+        /*
+         * register itself
+         */
+        usbhs_mod_register(priv, &gpriv->mod, USBHS_GADGET);
+
+        /* init gpriv */
+        gpriv->mod.name         = "gadget";
+        gpriv->mod.start        = usbhsg_start;
+        gpriv->mod.stop         = usbhsg_stop;
+        gpriv->uep              = uep;
+        gpriv->uep_size         = pipe_size;
+        usbhsg_status_init(gpriv);
+
+        /*
+         * init gadget
+         */
+        device_initialize(&gpriv->gadget.dev);
+        dev_set_name(&gpriv->gadget.dev, "gadget");
+        gpriv->gadget.dev.parent        = dev;
+        gpriv->gadget.name              = "renesas_usbhs_udc";
+        gpriv->gadget.ops               = &usbhsg_gadget_ops;
+        gpriv->gadget.is_dualspeed      = 1;
+
+        INIT_LIST_HEAD(&gpriv->gadget.ep_list);
+
+        /*
+         * init usb_ep
+         */
+        usbhsg_for_each_uep_with_dcp(uep, gpriv, i) {
+                uep->gpriv      = gpriv;
+                snprintf(uep->ep_name, EP_NAME_SIZE, "ep%d", i);
+
+                uep->ep.name            = uep->ep_name;
+                uep->ep.ops             = &usbhsg_ep_ops;
+                INIT_LIST_HEAD(&uep->ep.ep_list);
+                INIT_LIST_HEAD(&uep->list);
+
+                /* init DCP */
+                if (usbhsg_is_dcp(uep)) {
+                        gpriv->gadget.ep0 = &uep->ep;
+                        uep->ep.maxpacket = 64;
+                }
+                /* init normal pipe */
+                else {
+                        uep->ep.maxpacket = 512;
+                        list_add_tail(&uep->ep.ep_list, &gpriv->gadget.ep_list);
+                }
+        }
+
+        the_controller = gpriv;
+
+        dev_info(dev, "gadget probed\n");
+
+        return 0;
+
+usbhs_mod_gadget_probe_err_gpriv:
+        kfree(gpriv);
+
+        return -ENOMEM;
+}
+
+void __devexit usbhs_mod_gadget_remove(struct usbhs_priv *priv)
+{
+        struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
+
+        kfree(gpriv);
+}
diff --git a/drivers/usb/renesas_usbhs/pipe.c b/drivers/usb/renesas_usbhs/pipe.c
new file mode 100644
index 000000000000..5897ddad05f2
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/pipe.c
@@ -0,0 +1,877 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include "./common.h"
+#include "./pipe.h"
+
+/*
+ *              macros
+ */
+#define usbhsp_priv_to_pipeinfo(pr)     (&(pr)->pipe_info)
+#define usbhsp_pipe_to_priv(p)          ((p)->priv)
+
+#define usbhsp_addr_offset(p)   ((usbhs_pipe_number(p) - 1) * 2)
+
+#define usbhsp_is_dcp(p)        ((p)->priv->pipe_info.pipe == (p))
+
+#define usbhsp_flags_set(p, f)  ((p)->flags |=  USBHS_PIPE_FLAGS_##f)
+#define usbhsp_flags_clr(p, f)  ((p)->flags &= ~USBHS_PIPE_FLAGS_##f)
+#define usbhsp_flags_has(p, f)  ((p)->flags &   USBHS_PIPE_FLAGS_##f)
+#define usbhsp_flags_init(p)    do {(p)->flags = 0; } while (0)
+
+#define usbhsp_type(p)          ((p)->pipe_type)
+#define usbhsp_type_is(p, t)    ((p)->pipe_type == t)
+
+/*
+ * for debug
+ */
+static char *usbhsp_pipe_name[] = {
+        [USB_ENDPOINT_XFER_CONTROL]     = "DCP",
+        [USB_ENDPOINT_XFER_BULK]        = "BULK",
+        [USB_ENDPOINT_XFER_INT]         = "INT",
+        [USB_ENDPOINT_XFER_ISOC]        = "ISO",
+};
+
+/*
+ *              usb request functions
+ */
+void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
+{
+        u16 val;
+
+        val = usbhs_read(priv, USBREQ);
+        req->bRequest           = (val >> 8) & 0xFF;
+        req->bRequestType       = (val >> 0) & 0xFF;
+
+        req->wValue     = usbhs_read(priv, USBVAL);
+        req->wIndex     = usbhs_read(priv, USBINDX);
+        req->wLength    = usbhs_read(priv, USBLENG);
+}
+
+void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
+{
+        usbhs_write(priv, USBREQ,  (req->bRequest << 8) | req->bRequestType);
+        usbhs_write(priv, USBVAL,  req->wValue);
+        usbhs_write(priv, USBINDX, req->wIndex);
+        usbhs_write(priv, USBLENG, req->wLength);
+}
+
+/*
+ *              DCPCTR/PIPEnCTR functions
+ */
+static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        int offset = usbhsp_addr_offset(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                usbhs_bset(priv, DCPCTR, mask, val);
+        else
+                usbhs_bset(priv, PIPEnCTR + offset, mask, val);
+}
+
+static u16 usbhsp_pipectrl_get(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        int offset = usbhsp_addr_offset(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                return usbhs_read(priv, DCPCTR);
+        else
+                return usbhs_read(priv, PIPEnCTR + offset);
+}
+
+/*
+ *              DCP/PIPE functions
+ */
+static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe,
+                                  u16 dcp_reg, u16 pipe_reg,
+                                  u16 mask, u16 val)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                usbhs_bset(priv, dcp_reg, mask, val);
+        else
+                usbhs_bset(priv, pipe_reg, mask, val);
+}
+
+static u16 __usbhsp_pipe_xxx_get(struct usbhs_pipe *pipe,
+                                 u16 dcp_reg, u16 pipe_reg)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                return usbhs_read(priv, dcp_reg);
+        else
+                return usbhs_read(priv, pipe_reg);
+}
+
+/*
+ *              DCPCFG/PIPECFG functions
+ */
+static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
+{
+        __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val);
+}
+
+/*
+ *              PIPEBUF
+ */
+static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
+{
+        if (usbhsp_is_dcp(pipe))
+                return;
+
+        __usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val);
+}
+
+/*
+ *              DCPMAXP/PIPEMAXP
+ */
+static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
+{
+        __usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val);
+}
+
+static u16 usbhsp_pipe_maxp_get(struct usbhs_pipe *pipe)
+{
+        return __usbhsp_pipe_xxx_get(pipe, DCPMAXP, PIPEMAXP);
+}
+
+/*
+ *              pipe control functions
+ */
+static void usbhsp_pipe_select(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        /*
+         * On pipe, this is necessary before
+         * accesses to below registers.
+         *
+         * PIPESEL      : usbhsp_pipe_select
+         * PIPECFG      : usbhsp_pipe_cfg_xxx
+         * PIPEBUF      : usbhsp_pipe_buf_xxx
+         * PIPEMAXP     : usbhsp_pipe_maxp_xxx
+         * PIPEPERI
+         */
+
+        /*
+         * if pipe is dcp, no pipe is selected.
+         * it is no problem, because dcp have its register
+         */
+        usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe));
+}
+
+static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        struct device *dev = usbhs_priv_to_dev(priv);
+        int timeout = 1024;
+        u16 val;
+
+        /*
+         * make sure....
+         *
+         * Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is
+         * specified by the CURPIPE bits.
+         * When changing the setting of this bit after changing
+         * the PID bits for the selected pipe from BUF to NAK,
+         * check that CSSTS = 0 and PBUSY = 0.
+         */
+
+        /*
+         * CURPIPE bit = 0
+         *
+         * see also
+         *  "Operation"
+         *  - "Pipe Control"
+         *   - "Pipe Control Registers Switching Procedure"
+         */
+        usbhs_write(priv, CFIFOSEL, 0);
+
+        do {
+                val  = usbhsp_pipectrl_get(pipe);
+                val &= CSSTS | PID_MASK;
+                if (!val)
+                        return 0;
+
+                udelay(10);
+
+        } while (timeout--);
+
+        /*
+         * force NAK
+         */
+        timeout = 1024;
+        usbhs_fifo_disable(pipe);
+        do {
+                val  = usbhsp_pipectrl_get(pipe);
+                val &= PBUSY;
+                if (!val)
+                        return 0;
+
+        } while (timeout--);
+
+        dev_err(dev, "pipe barrier failed\n");
+
+        return -EBUSY;
+}
+
+static int usbhsp_pipe_is_accessible(struct usbhs_pipe *pipe)
+{
+        u16 val;
+
+        val = usbhsp_pipectrl_get(pipe);
+        if (val & BSTS)
+                return 0;
+
+        return -EBUSY;
+}
+
+/*
+ *              PID ctrl
+ */
+static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe)
+{
+        u16 pid = usbhsp_pipectrl_get(pipe);
+
+        pid &= PID_MASK;
+
+        /*
+         * see
+         * "Pipe n Control Register" - "PID"
+         */
+        switch (pid) {
+        case PID_STALL11:
+                usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
+                /* fall-through */
+        case PID_STALL10:
+                usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
+        }
+}
+
+void usbhs_fifo_disable(struct usbhs_pipe *pipe)
+{
+        /* see "Pipe n Control Register" - "PID" */
+        __usbhsp_pid_try_nak_if_stall(pipe);
+
+        usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
+}
+
+void usbhs_fifo_enable(struct usbhs_pipe *pipe)
+{
+        /* see "Pipe n Control Register" - "PID" */
+        __usbhsp_pid_try_nak_if_stall(pipe);
+
+        usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF);
+}
+
+void usbhs_fifo_stall(struct usbhs_pipe *pipe)
+{
+        u16 pid = usbhsp_pipectrl_get(pipe);
+
+        pid &= PID_MASK;
+
+        /*
+         * see
+         * "Pipe n Control Register" - "PID"
+         */
+        switch (pid) {
+        case PID_NAK:
+                usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
+                break;
+        case PID_BUF:
+                usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11);
+                break;
+        }
+}
+
+/*
+ *              CFIFO ctrl
+ */
+void usbhs_fifo_send_terminator(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        usbhs_bset(priv, CFIFOCTR, BVAL, BVAL);
+}
+
+static void usbhsp_fifo_clear(struct usbhs_pipe *pipe)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+
+        usbhs_write(priv, CFIFOCTR, BCLR);
+}
+
+static int usbhsp_fifo_barrier(struct usbhs_priv *priv)
+{
+        int timeout = 1024;
+
+        do {
+                /* The FIFO port is accessible */
+                if (usbhs_read(priv, CFIFOCTR) & FRDY)
+                        return 0;
+
+                udelay(10);
+        } while (timeout--);
+
+        return -EBUSY;
+}
+
+static int usbhsp_fifo_rcv_len(struct usbhs_priv *priv)
+{
+        return usbhs_read(priv, CFIFOCTR) & DTLN_MASK;
+}
+
+static int usbhsp_fifo_select(struct usbhs_pipe *pipe, int write)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        struct device *dev = usbhs_priv_to_dev(priv);
+        int timeout = 1024;
+        u16 mask = ((1 << 5) | 0xF);            /* mask of ISEL | CURPIPE */
+        u16 base = usbhs_pipe_number(pipe);     /* CURPIPE */
+
+        if (usbhsp_is_dcp(pipe))
+                base |= (1 == write) << 5;      /* ISEL */
+
+        /* "base" will be used below  */
+        usbhs_write(priv, CFIFOSEL, base | MBW_32);
+
+        /* check ISEL and CURPIPE value */
+        while (timeout--) {
+                if (base == (mask & usbhs_read(priv, CFIFOSEL)))
+                        return 0;
+                udelay(10);
+        }
+
+        dev_err(dev, "fifo select error\n");
+
+        return -EIO;
+}
+
+int usbhs_fifo_prepare_write(struct usbhs_pipe *pipe)
+{
+        return usbhsp_fifo_select(pipe, 1);
+}
+
+int usbhs_fifo_write(struct usbhs_pipe *pipe, u8 *buf, int len)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        void __iomem *addr = priv->base + CFIFO;
+        int maxp = usbhs_pipe_get_maxpacket(pipe);
+        int total_len;
+        int i, ret;
+
+        ret = usbhsp_pipe_is_accessible(pipe);
+        if (ret < 0)
+                return ret;
+
+        ret = usbhsp_fifo_select(pipe, 1);
+        if (ret < 0)
+                return ret;
+
+        ret = usbhsp_fifo_barrier(priv);
+        if (ret < 0)
+                return ret;
+
+        len = min(len, maxp);
+        total_len = len;
+
+        /*
+         * FIXME
+         *
+         * 32-bit access only
+         */
+        if (len >= 4 &&
+            !((unsigned long)buf & 0x03)) {
+                iowrite32_rep(addr, buf, len / 4);
+                len %= 4;
+                buf += total_len - len;
+        }
+
+        /* the rest operation */
+        for (i = 0; i < len; i++)
+                iowrite8(buf[i], addr + (0x03 - (i & 0x03)));
+
+        if (total_len < maxp)
+                usbhs_fifo_send_terminator(pipe);
+
+        return total_len;
+}
+
+int usbhs_fifo_prepare_read(struct usbhs_pipe *pipe)
+{
+        int ret;
+
+        /*
+         * select pipe and enable it to prepare packet receive
+         */
+        ret = usbhsp_fifo_select(pipe, 0);
+        if (ret < 0)
+                return ret;
+
+        usbhs_fifo_enable(pipe);
+
+        return ret;
+}
+
+int usbhs_fifo_read(struct usbhs_pipe *pipe, u8 *buf, int len)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        void __iomem *addr = priv->base + CFIFO;
+        int rcv_len;
+        int i, ret;
+        int total_len;
+        u32 data = 0;
+
+        ret = usbhsp_fifo_select(pipe, 0);
+        if (ret < 0)
+                return ret;
+
+        ret = usbhsp_fifo_barrier(priv);
+        if (ret < 0)
+                return ret;
+
+        rcv_len = usbhsp_fifo_rcv_len(priv);
+
+        /*
+         * Buffer clear if Zero-Length packet
+         *
+         * see
+         * "Operation" - "FIFO Buffer Memory" - "FIFO Port Function"
+         */
+        if (0 == rcv_len) {
+                usbhsp_fifo_clear(pipe);
+                return 0;
+        }
+
+        len = min(rcv_len, len);
+        total_len = len;
+
+        /*
+         * FIXME
+         *
+         * 32-bit access only
+         */
+        if (len >= 4 &&
+            !((unsigned long)buf & 0x03)) {
+                ioread32_rep(addr, buf, len / 4);
+                len %= 4;
+                buf += rcv_len - len;
+        }
+
+        /* the rest operation */
+        for (i = 0; i < len; i++) {
+                if (!(i & 0x03))
+                        data = ioread32(addr);
+
+                buf[i] = (data >> ((i & 0x03) * 8)) & 0xff;
+        }
+
+        return total_len;
+}
+
+/*
+ *              pipe setup
+ */
+static int usbhsp_possible_double_buffer(struct usbhs_pipe *pipe)
+{
+        /*
+         * only ISO / BULK pipe can use double buffer
+         */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK) ||
+            usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
+                return 1;
+
+        return 0;
+}
+
+static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe,
+                                const struct usb_endpoint_descriptor *desc,
+                                int is_host)
+{
+        u16 type = 0;
+        u16 bfre = 0;
+        u16 dblb = 0;
+        u16 cntmd = 0;
+        u16 dir = 0;
+        u16 epnum = 0;
+        u16 shtnak = 0;
+        u16 type_array[] = {
+                [USB_ENDPOINT_XFER_BULK] = TYPE_BULK,
+                [USB_ENDPOINT_XFER_INT]  = TYPE_INT,
+                [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO,
+        };
+        int is_double = usbhsp_possible_double_buffer(pipe);
+
+        if (usbhsp_is_dcp(pipe))
+                return -EINVAL;
+
+        /*
+         * PIPECFG
+         *
+         * see
+         *  - "Register Descriptions" - "PIPECFG" register
+         *  - "Features"  - "Pipe configuration"
+         *  - "Operation" - "Pipe Control"
+         */
+
+        /* TYPE */
+        type = type_array[usbhsp_type(pipe)];
+
+        /* BFRE */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
+            usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK))
+                bfre = 0; /* FIXME */
+
+        /* DBLB */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
+            usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK))
+                dblb = (is_double) ? DBLB : 0;
+
+        /* CNTMD */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK))
+                cntmd = 0; /* FIXME */
+
+        /* DIR */
+        if (usb_endpoint_dir_in(desc))
+                usbhsp_flags_set(pipe, IS_DIR_IN);
+
+        if ((is_host  && usb_endpoint_dir_out(desc)) ||
+            (!is_host && usb_endpoint_dir_in(desc)))
+                dir |= DIR_OUT;
+
+        /* SHTNAK */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK) &&
+            !dir)
+                shtnak = SHTNAK;
+
+        /* EPNUM */
+        epnum = 0xF & usb_endpoint_num(desc);
+
+        return  type    |
+                bfre    |
+                dblb    |
+                cntmd   |
+                dir     |
+                shtnak  |
+                epnum;
+}
+
+static u16 usbhsp_setup_pipemaxp(struct usbhs_pipe *pipe,
+                                 const struct usb_endpoint_descriptor *desc,
+                                 int is_host)
+{
+        /* host should set DEVSEL */
+
+        /* reutn MXPS */
+        return PIPE_MAXP_MASK & le16_to_cpu(desc->wMaxPacketSize);
+}
+
+static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe,
+                                 const struct usb_endpoint_descriptor *desc,
+                                 int is_host)
+{
+        struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe);
+        struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv);
+        struct device *dev = usbhs_priv_to_dev(priv);
+        int pipe_num = usbhs_pipe_number(pipe);
+        int is_double = usbhsp_possible_double_buffer(pipe);
+        u16 buff_size;
+        u16 bufnmb;
+        u16 bufnmb_cnt;
+
+        /*
+         * PIPEBUF
+         *
+         * see
+         *  - "Register Descriptions" - "PIPEBUF" register
+         *  - "Features"  - "Pipe configuration"
+         *  - "Operation" - "FIFO Buffer Memory"
+         *  - "Operation" - "Pipe Control"
+         *
+         * ex) if pipe6 - pipe9 are USB_ENDPOINT_XFER_INT (SH7724)
+         *
+         * BUFNMB:      PIPE
+         * 0:           pipe0 (DCP 256byte)
+         * 1:           -
+         * 2:           -
+         * 3:           -
+         * 4:           pipe6 (INT 64byte)
+         * 5:           pipe7 (INT 64byte)
+         * 6:           pipe8 (INT 64byte)
+         * 7:           pipe9 (INT 64byte)
+         * 8 - xx:      free (for BULK, ISOC)
+         */
+
+        /*
+         * FIXME
+         *
+         * it doesn't have good buffer allocator
+         *
+         * DCP : 256 byte
+         * BULK: 512 byte
+         * INT :  64 byte
+         * ISOC: 512 byte
+         */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_CONTROL))
+                buff_size = 256;
+        else if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT))
+                buff_size = 64;
+        else
+                buff_size = 512;
+
+        /* change buff_size to register value */
+        bufnmb_cnt = (buff_size / 64) - 1;
+
+        /* BUFNMB has been reserved for INT pipe
+         * see above */
+        if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT)) {
+                bufnmb = pipe_num - 2;
+        } else {
+                bufnmb = info->bufnmb_last;
+                info->bufnmb_last += bufnmb_cnt + 1;
+
+                /*
+                 * double buffer
+                 */
+                if (is_double)
+                        info->bufnmb_last += bufnmb_cnt + 1;
+        }
+
+        dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n",
+                pipe_num, buff_size, bufnmb);
+
+        return  (0x1f & bufnmb_cnt)     << 10 |
+                (0xff & bufnmb)         <<  0;
+}
+
+/*
+ *              pipe control
+ */
+int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe)
+{
+        u16 mask = usbhsp_is_dcp(pipe) ? DCP_MAXP_MASK : PIPE_MAXP_MASK;
+
+        usbhsp_pipe_select(pipe);
+
+        return (int)(usbhsp_pipe_maxp_get(pipe) & mask);
+}
+
+int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe)
+{
+        return usbhsp_flags_has(pipe, IS_DIR_IN);
+}
+
+void usbhs_pipe_clear_sequence(struct usbhs_pipe *pipe)
+{
+        usbhsp_pipectrl_set(pipe, SQCLR, SQCLR);
+}
+
+static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type)
+{
+        struct usbhs_pipe *pos, *pipe;
+        int i;
+
+        /*
+         * find target pipe
+         */
+        pipe = NULL;
+        usbhs_for_each_pipe_with_dcp(pos, priv, i) {
+                if (!usbhsp_type_is(pos, type))
+                        continue;
+                if (usbhsp_flags_has(pos, IS_USED))
+                        continue;
+
+                pipe = pos;
+                break;
+        }
+
+        if (!pipe)
+                return NULL;
+
+        /*
+         * initialize pipe flags
+         */
+        usbhsp_flags_init(pipe);
+        usbhsp_flags_set(pipe, IS_USED);
+
+        return pipe;
+}
+
+void usbhs_pipe_init(struct usbhs_priv *priv)
+{
+        struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv);
+        struct usbhs_pipe *pipe;
+        int i;
+
+        /*
+         * FIXME
+         *
+         * driver needs good allocator.
+         *
+         * find first free buffer area (BULK, ISOC)
+         * (DCP, INT area is fixed)
+         *
+         * buffer number 0 - 3 have been reserved for DCP
+         * see
+         *      usbhsp_to_bufnmb
+         */
+        info->bufnmb_last = 4;
+        usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+                if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT))
+                        info->bufnmb_last++;
+
+                usbhsp_flags_init(pipe);
+                pipe->mod_private = NULL;
+
+                usbhsp_fifo_clear(pipe);
+        }
+}
+
+struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv,
+                                     const struct usb_endpoint_descriptor *desc)
+{
+        struct device *dev = usbhs_priv_to_dev(priv);
+        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+        struct usbhs_pipe *pipe;
+        int is_host = usbhs_mod_is_host(priv, mod);
+        int ret;
+        u16 pipecfg, pipebuf, pipemaxp;
+
+        pipe = usbhsp_get_pipe(priv, usb_endpoint_type(desc));
+        if (!pipe) {
+                dev_err(dev, "can't get pipe (%s)\n",
+                        usbhsp_pipe_name[usb_endpoint_type(desc)]);
+                return NULL;
+        }
+
+        usbhs_fifo_disable(pipe);
+
+        /* make sure pipe is not busy */
+        ret = usbhsp_pipe_barrier(pipe);
+        if (ret < 0) {
+                dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe));
+                return NULL;
+        }
+
+        pipecfg  = usbhsp_setup_pipecfg(pipe,  desc, is_host);
+        pipebuf  = usbhsp_setup_pipebuff(pipe, desc, is_host);
+        pipemaxp = usbhsp_setup_pipemaxp(pipe, desc, is_host);
+
+        /* buffer clear
+         * see PIPECFG :: BFRE */
+        usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
+        usbhsp_pipectrl_set(pipe, ACLRM, 0);
+
+        usbhsp_pipe_select(pipe);
+        usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg);
+        usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf);
+        usbhsp_pipe_maxp_set(pipe, 0xFFFF, pipemaxp);
+
+        usbhs_pipe_clear_sequence(pipe);
+
+        dev_dbg(dev, "enable pipe %d : %s (%s)\n",
+                usbhs_pipe_number(pipe),
+                usbhsp_pipe_name[usb_endpoint_type(desc)],
+                usbhs_pipe_is_dir_in(pipe) ? "in" : "out");
+
+        return pipe;
+}
+
+/*
+ *              dcp control
+ */
+struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv)
+{
+        struct usbhs_pipe *pipe;
+
+        pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
+        if (!pipe)
+                return NULL;
+
+        /*
+         * dcpcfg  : default
+         * dcpmaxp : default
+         * pipebuf : nothing to do
+         */
+
+        usbhsp_pipe_select(pipe);
+        usbhs_pipe_clear_sequence(pipe);
+
+        return pipe;
+}
+
+void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
+{
+        WARN_ON(!usbhsp_is_dcp(pipe));
+
+        usbhs_fifo_enable(pipe);
+        usbhsp_pipectrl_set(pipe, CCPL, CCPL);
+}
+
+
+/*
+ *              pipe module function
+ */
+int usbhs_pipe_probe(struct usbhs_priv *priv)
+{
+        struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv);
+        struct usbhs_pipe *pipe;
+        struct device *dev = usbhs_priv_to_dev(priv);
+        u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
+        int pipe_size = usbhs_get_dparam(priv, pipe_size);
+        int i;
+
+        /* This driver expects 1st pipe is DCP */
+        if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) {
+                dev_err(dev, "1st PIPE is not DCP\n");
+                return -EINVAL;
+        }
+
+        info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
+        if (!info->pipe) {
+                dev_err(dev, "Could not allocate pipe\n");
+                return -ENOMEM;
+        }
+
+        info->size = pipe_size;
+
+        /*
+         * init pipe
+         */
+        usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+                pipe->priv = priv;
+                usbhsp_type(pipe) = pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK;
+
+                dev_dbg(dev, "pipe %x\t: %s\n",
+                        i, usbhsp_pipe_name[pipe_type[i]]);
+        }
+
+        return 0;
+}
+
+void usbhs_pipe_remove(struct usbhs_priv *priv)
+{
+        struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv);
+
+        kfree(info->pipe);
+}
diff --git a/drivers/usb/renesas_usbhs/pipe.h b/drivers/usb/renesas_usbhs/pipe.h
new file mode 100644
index 000000000000..1cca9b7fb266
--- /dev/null
+++ b/drivers/usb/renesas_usbhs/pipe.h
@@ -0,0 +1,104 @@
+/*
+ * Renesas USB driver
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#ifndef RENESAS_USB_PIPE_H
+#define RENESAS_USB_PIPE_H
+
+#include "./common.h"
+
+/*
+ *      struct
+ */
+struct usbhs_pipe {
+        u32 pipe_type;  /* USB_ENDPOINT_XFER_xxx */
+
+        struct usbhs_priv *priv;
+
+        u32 flags;
+#define USBHS_PIPE_FLAGS_IS_USED                (1 << 0)
+#define USBHS_PIPE_FLAGS_IS_DIR_IN              (1 << 1)
+
+        void *mod_private;
+};
+
+struct usbhs_pipe_info {
+        struct usbhs_pipe *pipe;
+        int size;       /* array size of "pipe" */
+        int bufnmb_last;        /* FIXME : driver needs good allocator */
+};
+
+/*
+ * pipe list
+ */
+#define __usbhs_for_each_pipe(start, pos, info, i)      \
+        for (i = start, pos = (info)->pipe;             \
+             i < (info)->size;                          \
+             i++, pos = (info)->pipe + i)
+
+#define usbhs_for_each_pipe(pos, priv, i)                       \
+        __usbhs_for_each_pipe(1, pos, &((priv)->pipe_info), i)
+
+#define usbhs_for_each_pipe_with_dcp(pos, priv, i)              \
+        __usbhs_for_each_pipe(0, pos, &((priv)->pipe_info), i)
+
+/*
+ * pipe module probe / remove
+ */
+int usbhs_pipe_probe(struct usbhs_priv *priv);
+void usbhs_pipe_remove(struct usbhs_priv *priv);
+
+/*
+ * cfifo
+ */
+int usbhs_fifo_write(struct usbhs_pipe *pipe, u8 *buf, int len);
+int usbhs_fifo_read(struct usbhs_pipe *pipe, u8 *buf, int len);
+int usbhs_fifo_prepare_write(struct usbhs_pipe *pipe);
+int usbhs_fifo_prepare_read(struct usbhs_pipe *pipe);
+
+void usbhs_fifo_enable(struct usbhs_pipe *pipe);
+void usbhs_fifo_disable(struct usbhs_pipe *pipe);
+void usbhs_fifo_stall(struct usbhs_pipe *pipe);
+
+void usbhs_fifo_send_terminator(struct usbhs_pipe *pipe);
+
+
+/*
+ * usb request
+ */
+void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req);
+void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req);
+
+/*
+ * pipe control
+ */
+struct usbhs_pipe
+*usbhs_pipe_malloc(struct usbhs_priv *priv,
+                   const struct usb_endpoint_descriptor *desc);
+
+int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe);
+void usbhs_pipe_init(struct usbhs_priv *priv);
+int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe);
+void usbhs_pipe_clear_sequence(struct usbhs_pipe *pipe);
+
+#define usbhs_pipe_number(p)    (int)((p) - (p)->priv->pipe_info.pipe)
+
+/*
+ * dcp control
+ */
+struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv);
+void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe);
+
+#endif /* RENESAS_USB_PIPE_H */
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index c2b29761fa98..b71e309116a3 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -527,15 +527,6 @@ config USB_SERIAL_SAFE_PADDED
         bool "USB Secure Encapsulated Driver - Padded"
         depends on USB_SERIAL_SAFE
 
-config USB_SERIAL_SAMBA
-        tristate "USB Atmel SAM Boot Assistant (SAM-BA) driver"
-        help
-          Say Y here if you want to access the SAM-BA boot application of an
-          Atmel AT91SAM device.
-
-          To compile this driver as a module, choose M here: the
-          module will be called sam-ba.
-
 config USB_SERIAL_SIEMENS_MPI
         tristate "USB Siemens MPI driver"
         help
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 9a2117f2b06e..9e536eefb32c 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -48,7 +48,6 @@ obj-$(CONFIG_USB_SERIAL_PL2303)			+= pl2303.o
 obj-$(CONFIG_USB_SERIAL_QCAUX)                  += qcaux.o
 obj-$(CONFIG_USB_SERIAL_QUALCOMM)               += qcserial.o
 obj-$(CONFIG_USB_SERIAL_SAFE)                   += safe_serial.o
-obj-$(CONFIG_USB_SERIAL_SAMBA)                  += sam-ba.o
 obj-$(CONFIG_USB_SERIAL_SIEMENS_MPI)            += siemens_mpi.o
 obj-$(CONFIG_USB_SERIAL_SIERRAWIRELESS)         += sierra.o
 obj-$(CONFIG_USB_SERIAL_SPCP8X5)                += spcp8x5.o
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index 0f11afdda134..ebeccb75558d 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -112,6 +112,10 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */
         { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
         { USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
+        { USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
+        { USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
+        { USB_DEVICE(0x10C4, 0x8664) }, /* AC-Services CAN-IF */
+        { USB_DEVICE(0x10C4, 0x8665) }, /* AC-Services OBD-IF */
         { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
         { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
         { USB_DEVICE(0x10C4, 0xEA71) }, /* Infinity GPS-MIC-1 Radio Monophone */
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 4de6ef0ae52a..e8dbde55f6c5 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -566,6 +566,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) },
         /*
          * ELV devices:
          */
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index efffc23723bd..1d946cd238ba 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -491,6 +491,11 @@
 /* www.canusb.com Lawicel CANUSB device (FTDI_VID) */
 #define FTDI_CANUSB_PID 0xFFA8 /* Product Id */
 
+/*
+ * TavIR AVR product ids (FTDI_VID)
+ */
+#define FTDI_TAVIR_STK500_PID   0xFA33  /* STK500 AVR programmer */
+
 
 
 /********************************/
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 26710b189918..b0a7a9e909a4 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -1,7 +1,7 @@
 /*
  * Garmin GPS driver
  *
- * Copyright (C) 2006-2009 Hermann Kneissel herkne@users.sourceforge.net
+ * Copyright (C) 2006-2011 Hermann Kneissel herkne@gmx.de
  *
  * The latest version of the driver can be found at
  * http://sourceforge.net/projects/garmin-gps/
@@ -51,7 +51,7 @@ static int debug;
  */
 
 #define VERSION_MAJOR   0
-#define VERSION_MINOR   33
+#define VERSION_MINOR   36
 
 #define _STR(s) #s
 #define _DRIVER_VERSION(a, b) "v" _STR(a) "." _STR(b)
@@ -410,6 +410,7 @@ static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
  */
 static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
 {
+        unsigned long flags;
         const __u8 *recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
         __le32 *usbdata = (__le32 *) garmin_data_p->inbuffer;
 
@@ -458,7 +459,9 @@ static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
         /* if this was an abort-transfer command, flush all
            queued data. */
         if (isAbortTrfCmnd(garmin_data_p->inbuffer)) {
+                spin_lock_irqsave(&garmin_data_p->lock, flags);
                 garmin_data_p->flags |= FLAGS_DROP_DATA;
+                spin_unlock_irqrestore(&garmin_data_p->lock, flags);
                 pkt_clear(garmin_data_p);
         }
 
@@ -943,7 +946,7 @@ static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port)
         spin_lock_irqsave(&garmin_data_p->lock, flags);
         garmin_data_p->mode  = initial_mode;
         garmin_data_p->count = 0;
-        garmin_data_p->flags = 0;
+        garmin_data_p->flags &= FLAGS_SESSION_REPLY1_SEEN;
         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
         /* shutdown any bulk reads that might be going on */
@@ -1178,7 +1181,8 @@ static int garmin_write_room(struct tty_struct *tty)
 
 
 static void garmin_read_process(struct garmin_data *garmin_data_p,
-                                 unsigned char *data, unsigned data_length)
+                                 unsigned char *data, unsigned data_length,
+                                 int bulk_data)
 {
         unsigned long flags;
 
@@ -1193,7 +1197,8 @@ static void garmin_read_process(struct garmin_data *garmin_data_p,
                    send it directly to the tty port */
                 if (garmin_data_p->flags & FLAGS_QUEUING) {
                         pkt_add(garmin_data_p, data, data_length);
-                } else if (getLayerId(data) == GARMIN_LAYERID_APPL) {
+                } else if (bulk_data || 
+                           getLayerId(data) == GARMIN_LAYERID_APPL) {
 
                         spin_lock_irqsave(&garmin_data_p->lock, flags);
                         garmin_data_p->flags |= APP_RESP_SEEN;
@@ -1237,7 +1242,7 @@ static void garmin_read_bulk_callback(struct urb *urb)
         usb_serial_debug_data(debug, &port->dev,
                                 __func__, urb->actual_length, data);
 
-        garmin_read_process(garmin_data_p, data, urb->actual_length);
+        garmin_read_process(garmin_data_p, data, urb->actual_length, 1);
 
         if (urb->actual_length == 0 &&
                         0 != (garmin_data_p->flags & FLAGS_BULK_IN_RESTART)) {
@@ -1346,7 +1351,7 @@ static void garmin_read_int_callback(struct urb *urb)
                         __func__, garmin_data_p->serial_num);
         }
 
-        garmin_read_process(garmin_data_p, data, urb->actual_length);
+        garmin_read_process(garmin_data_p, data, urb->actual_length, 0);
 
         port->interrupt_in_urb->dev = port->serial->dev;
         retval = usb_submit_urb(urb, GFP_ATOMIC);
@@ -1461,6 +1466,7 @@ static int garmin_attach(struct usb_serial *serial)
         garmin_data_p->timer.function = timeout_handler;
         garmin_data_p->port = port;
         garmin_data_p->state = 0;
+        garmin_data_p->flags = 0;
         garmin_data_p->count = 0;
         usb_set_serial_port_data(port, garmin_data_p);
 
diff --git a/drivers/usb/serial/moto_modem.c b/drivers/usb/serial/moto_modem.c
index 653465f61d4a..e2bfecc46402 100644
--- a/drivers/usb/serial/moto_modem.c
+++ b/drivers/usb/serial/moto_modem.c
@@ -25,6 +25,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x05c6, 0x3197) }, /* unknown Motorola phone */
         { USB_DEVICE(0x0c44, 0x0022) }, /* unknown Mororola phone */
         { USB_DEVICE(0x22b8, 0x2a64) }, /* Motorola KRZR K1m */
+        { USB_DEVICE(0x22b8, 0x2c84) }, /* Motorola VE240 phone */
         { USB_DEVICE(0x22b8, 0x2c64) }, /* Motorola V950 phone */
         { },
 };
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index d77ff0435896..4001f7630a54 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -972,7 +972,7 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD100) },
         { USB_DEVICE(CELOT_VENDOR_ID, CELOT_PRODUCT_CT680M) }, /* CT-650 CDMA 450 1xEVDO modem */
         { USB_DEVICE(ONDA_VENDOR_ID, ONDA_MT825UP) }, /* ONDA MT825UP modem */
-        { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730/GT-B3710 LTE USB modem.*/
+        { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730 LTE USB modem.*/
         { } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);
@@ -1109,6 +1109,12 @@ static int option_probe(struct usb_serial *serial,
                 serial->interface->cur_altsetting->desc.bInterfaceNumber == 1)
                 return -ENODEV;
 
+        /* Don't bind network interface on Samsung GT-B3730, it is handled by a separate module */
+        if (serial->dev->descriptor.idVendor == SAMSUNG_VENDOR_ID &&
+                serial->dev->descriptor.idProduct == SAMSUNG_PRODUCT_GT_B3730 &&
+                serial->interface->cur_altsetting->desc.bInterfaceClass != USB_CLASS_CDC_DATA)
+                return -ENODEV;
+
         data = serial->private = kzalloc(sizeof(struct usb_wwan_intf_private), GFP_KERNEL);
 
         if (!data)
diff --git a/drivers/usb/serial/sam-ba.c b/drivers/usb/serial/sam-ba.c
deleted file mode 100644
index e3bba64afc57..000000000000
--- a/drivers/usb/serial/sam-ba.c
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Atmel SAM Boot Assistant (SAM-BA) driver
- *
- * Copyright (C) 2010 Johan Hovold <jhovold@gmail.com>
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License version
- *      2 as published by the Free Software Foundation.
- */
-
-#include <linux/kernel.h>
-#include <linux/tty.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/usb.h>
-#include <linux/usb/serial.h>
-
-
-#define DRIVER_VERSION  "v1.0"
-#define DRIVER_AUTHOR   "Johan Hovold <jhovold@gmail.com>"
-#define DRIVER_DESC     "Atmel SAM Boot Assistant (SAM-BA) driver"
-
-#define SAMBA_VENDOR_ID         0x3eb
-#define SAMBA_PRODUCT_ID        0x6124
-
-
-static int debug;
-
-static const struct usb_device_id id_table[] = {
-        /*
-         * NOTE: Only match the CDC Data interface.
-         */
-        { USB_DEVICE_AND_INTERFACE_INFO(SAMBA_VENDOR_ID, SAMBA_PRODUCT_ID,
-                                        USB_CLASS_CDC_DATA, 0, 0) },
-        { }
-};
-MODULE_DEVICE_TABLE(usb, id_table);
-
-static struct usb_driver samba_driver = {
-        .name           = "sam-ba",
-        .probe          = usb_serial_probe,
-        .disconnect     = usb_serial_disconnect,
-        .id_table       = id_table,
-        .no_dynamic_id  = 1,
-};
-
-
-/*
- * NOTE: The SAM-BA firmware cannot handle merged write requests so we cannot
- *       use the generic write implementation (which uses the port write fifo).
- */
-static int samba_write(struct tty_struct *tty, struct usb_serial_port *port,
-                                        const unsigned char *buf, int count)
-{
-        struct urb *urb;
-        unsigned long flags;
-        int result;
-        int i;
-
-        if (!count)
-                return 0;
-
-        count = min_t(int, count, port->bulk_out_size);
-
-        spin_lock_irqsave(&port->lock, flags);
-        if (!port->write_urbs_free) {
-                spin_unlock_irqrestore(&port->lock, flags);
-                return 0;
-        }
-        i = find_first_bit(&port->write_urbs_free,
-                                                ARRAY_SIZE(port->write_urbs));
-        __clear_bit(i, &port->write_urbs_free);
-        port->tx_bytes += count;
-        spin_unlock_irqrestore(&port->lock, flags);
-
-        urb = port->write_urbs[i];
-        memcpy(urb->transfer_buffer, buf, count);
-        urb->transfer_buffer_length = count;
-        usb_serial_debug_data(debug, &port->dev, __func__, count,
-                                                urb->transfer_buffer);
-        result = usb_submit_urb(urb, GFP_ATOMIC);
-        if (result) {
-                dev_err(&port->dev, "%s - error submitting urb: %d\n",
-                                                __func__, result);
-                spin_lock_irqsave(&port->lock, flags);
-                __set_bit(i, &port->write_urbs_free);
-                port->tx_bytes -= count;
-                spin_unlock_irqrestore(&port->lock, flags);
-
-                return result;
-        }
-
-        return count;
-}
-
-static int samba_write_room(struct tty_struct *tty)
-{
-        struct usb_serial_port *port = tty->driver_data;
-        unsigned long flags;
-        unsigned long free;
-        int count;
-        int room;
-
-        spin_lock_irqsave(&port->lock, flags);
-        free = port->write_urbs_free;
-        spin_unlock_irqrestore(&port->lock, flags);
-
-        count = hweight_long(free);
-        room = count * port->bulk_out_size;
-
-        dbg("%s - returns %d", __func__, room);
-
-        return room;
-}
-
-static int samba_chars_in_buffer(struct tty_struct *tty)
-{
-        struct usb_serial_port *port = tty->driver_data;
-        unsigned long flags;
-        int chars;
-
-        spin_lock_irqsave(&port->lock, flags);
-        chars = port->tx_bytes;
-        spin_unlock_irqrestore(&port->lock, flags);
-
-        dbg("%s - returns %d", __func__, chars);
-
-        return chars;
-}
-
-static void samba_write_bulk_callback(struct urb *urb)
-{
-        struct usb_serial_port *port = urb->context;
-        unsigned long flags;
-        int i;
-
-        dbg("%s - port %d", __func__, port->number);
-
-        for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
-                if (port->write_urbs[i] == urb)
-                        break;
-        }
-        spin_lock_irqsave(&port->lock, flags);
-        __set_bit(i, &port->write_urbs_free);
-        port->tx_bytes -= urb->transfer_buffer_length;
-        spin_unlock_irqrestore(&port->lock, flags);
-
-        if (urb->status)
-                dbg("%s - non-zero urb status: %d", __func__, urb->status);
-
-        usb_serial_port_softint(port);
-}
-
-static struct usb_serial_driver samba_device = {
-        .driver = {
-                .owner          = THIS_MODULE,
-                .name           = "sam-ba",
-        },
-        .usb_driver             = &samba_driver,
-        .id_table               = id_table,
-        .num_ports              = 1,
-        .bulk_in_size           = 512,
-        .bulk_out_size          = 2048,
-        .write                  = samba_write,
-        .write_room             = samba_write_room,
-        .chars_in_buffer        = samba_chars_in_buffer,
-        .write_bulk_callback    = samba_write_bulk_callback,
-        .throttle               = usb_serial_generic_throttle,
-        .unthrottle             = usb_serial_generic_unthrottle,
-};
-
-static int __init samba_init(void)
-{
-        int retval;
-
-        retval = usb_serial_register(&samba_device);
-        if (retval)
-                return retval;
-
-        retval = usb_register(&samba_driver);
-        if (retval) {
-                usb_serial_deregister(&samba_device);
-                return retval;
-        }
-
-        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ": "
-                                                        DRIVER_DESC "\n");
-        return 0;
-}
-
-static void __exit samba_exit(void)
-{
-        usb_deregister(&samba_driver);
-        usb_serial_deregister(&samba_device);
-}
-
-module_init(samba_init);
-module_exit(samba_exit);
-
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_VERSION(DRIVER_VERSION);
-MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Enable verbose debugging messages");
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index 4eb56ed75fbc..fffdf00f87b9 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -72,6 +72,7 @@ struct fsl_usb2_platform_data {
         void            (*exit)(struct platform_device *);
         void __iomem    *regs;          /* ioremap'd register base */
         struct clk      *clk;
+        unsigned        power_budget;   /* hcd->power_budget */
         unsigned        big_endian_mmio:1;
         unsigned        big_endian_desc:1;
         unsigned        es:1;           /* need USBMODE:ES */
@@ -79,6 +80,21 @@ struct fsl_usb2_platform_data {
         unsigned        have_sysif_regs:1;
         unsigned        invert_drvvbus:1;
         unsigned        invert_pwr_fault:1;
+
+        unsigned        suspended:1;
+        unsigned        already_suspended:1;
+
+        /* register save area for suspend/resume */
+        u32             pm_command;
+        u32             pm_status;
+        u32             pm_intr_enable;
+        u32             pm_frame_index;
+        u32             pm_segment;
+        u32             pm_frame_list;
+        u32             pm_async_next;
+        u32             pm_configured_flag;
+        u32             pm_portsc;
+        u32             pm_usbgenctrl;
 };
 
 /* Flags in fsl_usb2_mph_platform_data */
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 65f78ca5d88e..73c7df489607 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -806,8 +806,10 @@ struct usbdrv_wrap {
  * @resume: Called when the device is being resumed by the system.
  * @reset_resume: Called when the suspended device has been reset instead
  *      of being resumed.
- * @pre_reset: Called by usb_reset_device() when the device
- *      is about to be reset.
+ * @pre_reset: Called by usb_reset_device() when the device is about to be
+ *      reset.  This routine must not return until the driver has no active
+ *      URBs for the device, and no more URBs may be submitted until the
+ *      post_reset method is called.
  * @post_reset: Called by usb_reset_device() after the device
  *      has been reset
  * @id_table: USB drivers use ID table to support hotplugging.
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index b72f305ce6bd..0fd3fbdd8283 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -579,7 +579,7 @@ struct usb_ss_ep_comp_descriptor {
 
         __u8  bMaxBurst;
         __u8  bmAttributes;
-        __u16 wBytesPerInterval;
+        __le16 wBytesPerInterval;
 } __attribute__ ((packed));
 
 #define USB_DT_SS_EP_COMP_SIZE          6
diff --git a/include/linux/usb/ehci_def.h b/include/linux/usb/ehci_def.h
index e49dfd45baa4..7cc95ee3606b 100644
--- a/include/linux/usb/ehci_def.h
+++ b/include/linux/usb/ehci_def.h
@@ -25,10 +25,15 @@
 struct ehci_caps {
         /* these fields are specified as 8 and 16 bit registers,
          * but some hosts can't perform 8 or 16 bit PCI accesses.
+         * some hosts treat caplength and hciversion as parts of a 32-bit
+         * register, others treat them as two separate registers, this
+         * affects the memory map for big endian controllers.
          */
         u32             hc_capbase;
-#define HC_LENGTH(p)            (((p)>>00)&0x00ff)      /* bits 7:0 */
-#define HC_VERSION(p)           (((p)>>16)&0xffff)      /* bits 31:16 */
+#define HC_LENGTH(ehci, p)      (0x00ff&((p) >> /* bits 7:0 / offset 00h */ \
+                                (ehci_big_endian_capbase(ehci) ? 24 : 0)))
+#define HC_VERSION(ehci, p)     (0xffff&((p) >> /* bits 31:16 / offset 02h */ \
+                                (ehci_big_endian_capbase(ehci) ? 0 : 16)))
         u32             hcs_params;     /* HCSPARAMS - offset 0x4 */
 #define HCS_DEBUG_PORT(p)       (((p)>>20)&0xf) /* bits 23:20, debug port? */
 #define HCS_INDICATOR(p)        ((p)&(1 << 16)) /* true: has port indicators */
@@ -52,7 +57,7 @@ struct ehci_caps {
 #define HCC_PGM_FRAMELISTLEN(p) ((p)&(1 << 1))  /* true: periodic_size changes*/
 #define HCC_64BIT_ADDR(p)       ((p)&(1))       /* true: can use 64-bit addr */
         u8              portroute[8];    /* nibbles for routing - offset 0xC */
-} __attribute__ ((packed));
+};
 
 
 /* Section 2.3 Host Controller Operational Registers */
@@ -150,7 +155,7 @@ struct ehci_regs {
 #define PORT_CSC        (1<<1)          /* connect status change */
 #define PORT_CONNECT    (1<<0)          /* device connected */
 #define PORT_RWC_BITS   (PORT_CSC | PORT_PEC | PORT_OCC)
-} __attribute__ ((packed));
+};
 
 #define USBMODE         0x68            /* USB Device mode */
 #define USBMODE_SDIS    (1<<3)          /* Stream disable */
@@ -194,7 +199,7 @@ struct ehci_dbg_port {
         u32     data47;
         u32     address;
 #define DBGP_EPADDR(dev, ep)    (((dev)<<8)|(ep))
-} __attribute__ ((packed));
+};
 
 #ifdef CONFIG_EARLY_PRINTK_DBGP
 #include <linux/init.h>
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index e538172c0f64..dd1571db55e7 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -890,8 +890,8 @@ static inline void usb_free_descriptors(struct usb_descriptor_header **v)
 /* utility wrapping a simple endpoint selection policy */
 
 extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
-                        struct usb_endpoint_descriptor *) __devinit;
+                        struct usb_endpoint_descriptor *);
 
-extern void usb_ep_autoconfig_reset(struct usb_gadget *) __devinit;
+extern void usb_ep_autoconfig_reset(struct usb_gadget *);
 
 #endif /* __LINUX_USB_GADGET_H */
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
index 3657403eac18..00311fe9d0df 100644
--- a/include/linux/usb/msm_hsusb.h
+++ b/include/linux/usb/msm_hsusb.h
@@ -2,7 +2,7 @@
  *
  * Copyright (C) 2008 Google, Inc.
  * Author: Brian Swetland <swetland@google.com>
- * Copyright (c) 2009-2010, Code Aurora Forum. All rights reserved.
+ * Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
@@ -54,6 +54,64 @@ enum otg_control_type {
 };
 
 /**
+ * PHY used in
+ *
+ * INVALID_PHY                  Unsupported PHY
+ * CI_45NM_INTEGRATED_PHY       Chipidea 45nm integrated PHY
+ * SNPS_28NM_INTEGRATED_PHY     Synopsis 28nm integrated PHY
+ *
+ */
+enum msm_usb_phy_type {
+        INVALID_PHY = 0,
+        CI_45NM_INTEGRATED_PHY,
+        SNPS_28NM_INTEGRATED_PHY,
+};
+
+#define IDEV_CHG_MAX    1500
+#define IUNIT           100
+
+/**
+ * Different states involved in USB charger detection.
+ *
+ * USB_CHG_STATE_UNDEFINED      USB charger is not connected or detection
+ *                              process is not yet started.
+ * USB_CHG_STATE_WAIT_FOR_DCD   Waiting for Data pins contact.
+ * USB_CHG_STATE_DCD_DONE       Data pin contact is detected.
+ * USB_CHG_STATE_PRIMARY_DONE   Primary detection is completed (Detects
+ *                              between SDP and DCP/CDP).
+ * USB_CHG_STATE_SECONDARY_DONE Secondary detection is completed (Detects
+ *                              between DCP and CDP).
+ * USB_CHG_STATE_DETECTED       USB charger type is determined.
+ *
+ */
+enum usb_chg_state {
+        USB_CHG_STATE_UNDEFINED = 0,
+        USB_CHG_STATE_WAIT_FOR_DCD,
+        USB_CHG_STATE_DCD_DONE,
+        USB_CHG_STATE_PRIMARY_DONE,
+        USB_CHG_STATE_SECONDARY_DONE,
+        USB_CHG_STATE_DETECTED,
+};
+
+/**
+ * USB charger types
+ *
+ * USB_INVALID_CHARGER  Invalid USB charger.
+ * USB_SDP_CHARGER      Standard downstream port. Refers to a downstream port
+ *                      on USB2.0 compliant host/hub.
+ * USB_DCP_CHARGER      Dedicated charger port (AC charger/ Wall charger).
+ * USB_CDP_CHARGER      Charging downstream port. Enumeration can happen and
+ *                      IDEV_CHG_MAX can be drawn irrespective of USB state.
+ *
+ */
+enum usb_chg_type {
+        USB_INVALID_CHARGER = 0,
+        USB_SDP_CHARGER,
+        USB_DCP_CHARGER,
+        USB_CDP_CHARGER,
+};
+
+/**
  * struct msm_otg_platform_data - platform device data
  *              for msm_otg driver.
  * @phy_init_seq: PHY configuration sequence. val, reg pairs
@@ -64,7 +122,8 @@ enum otg_control_type {
  * @otg_control: OTG switch controlled by user/Id pin
  * @default_mode: Default operational mode. Applicable only if
  *              OTG switch is controller by user.
- *
+ * @pclk_src_name: pclk is derived from ebi1_usb_clk in case of 7x27 and 8k
+ *              dfab_usb_hs_clk in case of 8660 and 8960.
  */
 struct msm_otg_platform_data {
         int *phy_init_seq;
@@ -73,7 +132,9 @@ struct msm_otg_platform_data {
         enum usb_mode_type mode;
         enum otg_control_type otg_control;
         enum usb_mode_type default_mode;
+        enum msm_usb_phy_type phy_type;
         void (*setup_gpio)(enum usb_otg_state state);
+        char *pclk_src_name;
 };
 
 /**
@@ -83,6 +144,7 @@ struct msm_otg_platform_data {
  * @irq: IRQ number assigned for HSUSB controller.
  * @clk: clock struct of usb_hs_clk.
  * @pclk: clock struct of usb_hs_pclk.
+ * @pclk_src: pclk source for voting.
  * @phy_reset_clk: clock struct of usb_phy_clk.
  * @core_clk: clock struct of usb_hs_core_clk.
  * @regs: ioremapped register base address.
@@ -90,7 +152,12 @@ struct msm_otg_platform_data {
  * @sm_work: OTG state machine work.
  * @in_lpm: indicates low power mode (LPM) state.
  * @async_int: Async interrupt arrived.
- *
+ * @cur_power: The amount of mA available from downstream port.
+ * @chg_work: Charger detection work.
+ * @chg_state: The state of charger detection process.
+ * @chg_type: The type of charger attached.
+ * @dcd_retires: The retry count used to track Data contact
+ *               detection process.
  */
 struct msm_otg {
         struct otg_transceiver otg;
@@ -98,6 +165,7 @@ struct msm_otg {
         int irq;
         struct clk *clk;
         struct clk *pclk;
+        struct clk *pclk_src;
         struct clk *phy_reset_clk;
         struct clk *core_clk;
         void __iomem *regs;
@@ -107,6 +175,11 @@ struct msm_otg {
         struct work_struct sm_work;
         atomic_t in_lpm;
         int async_int;
+        unsigned cur_power;
+        struct delayed_work chg_work;
+        enum usb_chg_state chg_state;
+        enum usb_chg_type chg_type;
+        u8 dcd_retries;
 };
 
 #endif
diff --git a/include/linux/usb/msm_hsusb_hw.h b/include/linux/usb/msm_hsusb_hw.h
index 7d1babbff071..6e97a2d3d39f 100644
--- a/include/linux/usb/msm_hsusb_hw.h
+++ b/include/linux/usb/msm_hsusb_hw.h
@@ -24,6 +24,7 @@
 #define USB_PORTSC           (MSM_USB_BASE + 0x0184)
 #define USB_OTGSC            (MSM_USB_BASE + 0x01A4)
 #define USB_USBMODE          (MSM_USB_BASE + 0x01A8)
+#define USB_PHY_CTRL         (MSM_USB_BASE + 0x0240)
 
 #define USBCMD_RESET   2
 #define USB_USBINTR          (MSM_USB_BASE + 0x0148)
@@ -42,6 +43,7 @@
 
 #define ASYNC_INTR_CTRL         (1 << 29) /* Enable async interrupt */
 #define ULPI_STP_CTRL           (1 << 30) /* Block communication with PHY */
+#define PHY_RETEN               (1 << 1) /* PHY retention enable/disable */
 
 /* OTG definitions */
 #define OTGSC_INTSTS_MASK       (0x7f << 16)
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index 6e40718f5abe..d87f44f5b04e 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -168,6 +168,7 @@ otg_shutdown(struct otg_transceiver *otg)
 #ifdef CONFIG_USB_OTG_UTILS
 extern struct otg_transceiver *otg_get_transceiver(void);
 extern void otg_put_transceiver(struct otg_transceiver *);
+extern const char *otg_state_string(enum usb_otg_state state);
 #else
 static inline struct otg_transceiver *otg_get_transceiver(void)
 {
@@ -177,6 +178,11 @@ static inline struct otg_transceiver *otg_get_transceiver(void)
 static inline void otg_put_transceiver(struct otg_transceiver *x)
 {
 }
+
+static inline const char *otg_state_string(enum usb_otg_state state)
+{
+        return NULL;
+}
 #endif
 
 /* Context: can sleep */
diff --git a/include/linux/usb/renesas_usbhs.h b/include/linux/usb/renesas_usbhs.h
new file mode 100644
index 000000000000..3a7f1d982dd6
--- /dev/null
+++ b/include/linux/usb/renesas_usbhs.h
@@ -0,0 +1,156 @@
+/*
+ * Renesas USB
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#ifndef RENESAS_USB_H
+#define RENESAS_USB_H
+#include <linux/platform_device.h>
+#include <linux/usb/ch9.h>
+
+/*
+ * module type
+ *
+ * it will be return value from get_id
+ */
+enum {
+        USBHS_HOST = 0,
+        USBHS_GADGET,
+        USBHS_MAX,
+};
+
+/*
+ * callback functions table for driver
+ *
+ * These functions are called from platform for driver.
+ * Callback function's pointer will be set before
+ * renesas_usbhs_platform_callback :: hardware_init was called
+ */
+struct renesas_usbhs_driver_callback {
+        int (*notify_hotplug)(struct platform_device *pdev);
+};
+
+/*
+ * callback functions for platform
+ *
+ * These functions are called from driver for platform
+ */
+struct renesas_usbhs_platform_callback {
+
+        /*
+         * option:
+         *
+         * Hardware init function for platform.
+         * it is called when driver was probed.
+         */
+        int (*hardware_init)(struct platform_device *pdev);
+
+        /*
+         * option:
+         *
+         * Hardware exit function for platform.
+         * it is called when driver was removed
+         */
+        void (*hardware_exit)(struct platform_device *pdev);
+
+        /*
+         * option:
+         *
+         * Phy reset for platform
+         */
+        void (*phy_reset)(struct platform_device *pdev);
+
+        /*
+         * get USB ID function
+         *  - USBHS_HOST
+         *  - USBHS_GADGET
+         */
+        int (*get_id)(struct platform_device *pdev);
+
+        /*
+         * get VBUS status function.
+         */
+        int (*get_vbus)(struct platform_device *pdev);
+};
+
+/*
+ * parameters for renesas usbhs
+ *
+ * some register needs USB chip specific parameters.
+ * This struct show it to driver
+ */
+struct renesas_usbhs_driver_param {
+        /*
+         * pipe settings
+         */
+        u32 *pipe_type; /* array of USB_ENDPOINT_XFER_xxx (from ep0) */
+        int pipe_size; /* pipe_type array size */
+
+        /*
+         * option:
+         *
+         * for BUSWAIT :: BWAIT
+         * */
+        int buswait_bwait;
+
+        /*
+         * option:
+         *
+         * delay time from notify_hotplug callback
+         */
+        int detection_delay;
+};
+
+/*
+ * option:
+ *
+ * platform information for renesas_usbhs driver.
+ */
+struct renesas_usbhs_platform_info {
+        /*
+         * option:
+         *
+         * platform set these functions before
+         * call platform_add_devices if needed
+         */
+        struct renesas_usbhs_platform_callback  platform_callback;
+
+        /*
+         * driver set these callback functions pointer.
+         * platform can use it on callback functions
+         */
+        struct renesas_usbhs_driver_callback    driver_callback;
+
+        /*
+         * option:
+         *
+         * driver use these param for some register
+         */
+        struct renesas_usbhs_driver_param       driver_param;
+};
+
+/*
+ * macro for platform
+ */
+#define renesas_usbhs_get_info(pdev)\
+        ((struct renesas_usbhs_platform_info *)(pdev)->dev.platform_data)
+
+#define renesas_usbhs_call_notify_hotplug(pdev)                         \
+        ({                                                              \
+                struct renesas_usbhs_driver_callback *dc;               \
+                dc = &(renesas_usbhs_get_info(pdev)->driver_callback);  \
+                if (dc && dc->notify_hotplug)                           \
+                        dc->notify_hotplug(pdev);                       \
+        })
+#endif /* RENESAS_USB_H */