126 files changed, 9603 insertions, 2137 deletions

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index c363840cdcea..6fa7292947e5 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -671,7 +671,7 @@ and is between 256 and 4096 characters. It is defined in the file
         earlyprintk=    [X86,SH,BLACKFIN]
                         earlyprintk=vga
                         earlyprintk=serial[,ttySn[,baudrate]]
-                        earlyprintk=dbgp
+                        earlyprintk=dbgp[debugController#]
 
                         Append ",keep" to not disable it when the real console
                         takes over.
diff --git a/Documentation/usb/authorization.txt b/Documentation/usb/authorization.txt
index 381b22ee7834..c069b6884c77 100644
--- a/Documentation/usb/authorization.txt
+++ b/Documentation/usb/authorization.txt
@@ -16,20 +16,20 @@ Usage:
 
 Authorize a device to connect:
 
-$ echo 1 > /sys/usb/devices/DEVICE/authorized
+$ echo 1 > /sys/bus/usb/devices/DEVICE/authorized
 
 Deauthorize a device:
 
-$ echo 0 > /sys/usb/devices/DEVICE/authorized
+$ echo 0 > /sys/bus/usb/devices/DEVICE/authorized
 
 Set new devices connected to hostX to be deauthorized by default (ie:
 lock down):
 
-$ echo 0 > /sys/bus/devices/usbX/authorized_default
+$ echo 0 > /sys/bus/usb/devices/usbX/authorized_default
 
 Remove the lock down:
 
-$ echo 1 > /sys/bus/devices/usbX/authorized_default
+$ echo 1 > /sys/bus/usb/devices/usbX/authorized_default
 
 By default, Wired USB devices are authorized by default to
 connect. Wireless USB hosts deauthorize by default all new connected
@@ -47,7 +47,7 @@ USB port):
 boot up
 rc.local ->
 
- for host in /sys/bus/devices/usb*
+ for host in /sys/bus/usb/devices/usb*
  do
     echo 0 > $host/authorized_default
  done
diff --git a/Documentation/usb/usbmon.txt b/Documentation/usb/usbmon.txt
index 6c3c625b7f30..66f92d1194c1 100644
--- a/Documentation/usb/usbmon.txt
+++ b/Documentation/usb/usbmon.txt
@@ -33,7 +33,7 @@ if usbmon is built into the kernel.
 
 Verify that bus sockets are present.
 
-# ls /sys/kernel/debug/usbmon
+# ls /sys/kernel/debug/usb/usbmon
 0s  0u  1s  1t  1u  2s  2t  2u  3s  3t  3u  4s  4t  4u
 #
 
@@ -58,11 +58,11 @@ Bus=03 means it's bus 3.
 
 3. Start 'cat'
 
-# cat /sys/kernel/debug/usbmon/3u > /tmp/1.mon.out
+# cat /sys/kernel/debug/usb/usbmon/3u > /tmp/1.mon.out
 
 to listen on a single bus, otherwise, to listen on all buses, type:
 
-# cat /sys/kernel/debug/usbmon/0u > /tmp/1.mon.out
+# cat /sys/kernel/debug/usb/usbmon/0u > /tmp/1.mon.out
 
 This process will be reading until killed. Naturally, the output can be
 redirected to a desirable location. This is preferred, because it is going
@@ -305,7 +305,7 @@ Before the call, hdr, data, and alloc should be filled. Upon return, the area
 pointed by hdr contains the next event structure, and the data buffer contains
 the data, if any. The event is removed from the kernel buffer.
 
-The MON_IOCX_GET copies 48 bytes, MON_IOCX_GETX copies 64 bytes.
+The MON_IOCX_GET copies 48 bytes to hdr area, MON_IOCX_GETX copies 64 bytes.
 
  MON_IOCX_MFETCH, defined as _IOWR(MON_IOC_MAGIC, 7, struct mon_mfetch_arg)
 
diff --git a/Documentation/x86/earlyprintk.txt b/Documentation/x86/earlyprintk.txt
index 607b1a016064..f19802c0f485 100644
--- a/Documentation/x86/earlyprintk.txt
+++ b/Documentation/x86/earlyprintk.txt
@@ -7,7 +7,7 @@ and two USB cables, connected like this:
 
   [host/target] <-------> [USB debug key] <-------> [client/console]
 
-1. There are three specific hardware requirements:
+1. There are a number of specific hardware requirements:
 
  a.) Host/target system needs to have USB debug port capability.
 
@@ -42,7 +42,35 @@ and two USB cables, connected like this:
      This is a small blue plastic connector with two USB connections,
      it draws power from its USB connections.
 
- c.) Thirdly, you need a second client/console system with a regular USB port.
+ c.) You need a second client/console system with a high speed USB 2.0
+     port.
+
+ d.) The Netchip device must be plugged directly into the physical
+     debug port on the "host/target" system.  You cannot use a USB hub in
+     between the physical debug port and the "host/target" system.
+
+     The EHCI debug controller is bound to a specific physical USB
+     port and the Netchip device will only work as an early printk
+     device in this port.  The EHCI host controllers are electrically
+     wired such that the EHCI debug controller is hooked up to the
+     first physical and there is no way to change this via software.
+     You can find the physical port through experimentation by trying
+     each physical port on the system and rebooting.  Or you can try
+     and use lsusb or look at the kernel info messages emitted by the
+     usb stack when you plug a usb device into various ports on the
+     "host/target" system.
+
+     Some hardware vendors do not expose the usb debug port with a
+     physical connector and if you find such a device send a complaint
+     to the hardware vendor, because there is no reason not to wire
+     this port into one of the physically accessible ports.
+
+ e.) It is also important to note, that many versions of the Netchip
+     device require the "client/console" system to be plugged into the
+     right and side of the device (with the product logo facing up and
+     readable left to right).  The reason being is that the 5 volt
+     power supply is taken from only one side of the device and it
+     must be the side that does not get rebooted.
 
 2. Software requirements:
 
@@ -56,6 +84,13 @@ and two USB cables, connected like this:
     (If you are using Grub, append it to the 'kernel' line in
      /etc/grub.conf)
 
+    On systems with more than one EHCI debug controller you must
+    specify the correct EHCI debug controller number.  The ordering
+    comes from the PCI bus enumeration of the EHCI controllers.  The
+    default with no number argument is "0" the first EHCI debug
+    controller.  To use the second EHCI debug controller, you would
+    use the command line: "earlyprintk=dbgp1"
+
     NOTE: normally earlyprintk console gets turned off once the
     regular console is alive - use "earlyprintk=dbgp,keep" to keep
     this channel open beyond early bootup. This can be useful for
diff --git a/MAINTAINERS b/MAINTAINERS
index ed6cd99a57ba..e1fc32e394aa 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2107,12 +2107,12 @@ S:	Supported
 F:      arch/powerpc/sysdev/qe_lib/
 F:      arch/powerpc/include/asm/*qe.h
 
-FREESCALE HIGHSPEED USB DEVICE DRIVER
+FREESCALE USB PERIPHERIAL DRIVERS
 M:      Li Yang <leoli@freescale.com>
 L:      linux-usb@vger.kernel.org
 L:      linuxppc-dev@ozlabs.org
 S:      Maintained
-F:      drivers/usb/gadget/fsl_usb2_udc.c
+F:      drivers/usb/gadget/fsl*
 
 FREESCALE QUICC ENGINE UCC ETHERNET DRIVER
 M:      Li Yang <leoli@freescale.com>
diff --git a/arch/x86/kernel/early_printk.c b/arch/x86/kernel/early_printk.c
index b11cab3c323a..2acfd3fdc0cc 100644
--- a/arch/x86/kernel/early_printk.c
+++ b/arch/x86/kernel/early_printk.c
@@ -160,721 +160,6 @@ static struct console early_serial_console = {
         .index =        -1,
 };
 
-#ifdef CONFIG_EARLY_PRINTK_DBGP
-
-static struct ehci_caps __iomem *ehci_caps;
-static struct ehci_regs __iomem *ehci_regs;
-static struct ehci_dbg_port __iomem *ehci_debug;
-static unsigned int dbgp_endpoint_out;
-
-struct ehci_dev {
-        u32 bus;
-        u32 slot;
-        u32 func;
-};
-
-static struct ehci_dev ehci_dev;
-
-#define USB_DEBUG_DEVNUM 127
-
-#define DBGP_DATA_TOGGLE        0x8800
-
-static inline u32 dbgp_pid_update(u32 x, u32 tok)
-{
-        return ((x ^ DBGP_DATA_TOGGLE) & 0xffff00) | (tok & 0xff);
-}
-
-static inline u32 dbgp_len_update(u32 x, u32 len)
-{
-        return (x & ~0x0f) | (len & 0x0f);
-}
-
-/*
- * USB Packet IDs (PIDs)
- */
-
-/* token */
-#define USB_PID_OUT             0xe1
-#define USB_PID_IN              0x69
-#define USB_PID_SOF             0xa5
-#define USB_PID_SETUP           0x2d
-/* handshake */
-#define USB_PID_ACK             0xd2
-#define USB_PID_NAK             0x5a
-#define USB_PID_STALL           0x1e
-#define USB_PID_NYET            0x96
-/* data */
-#define USB_PID_DATA0           0xc3
-#define USB_PID_DATA1           0x4b
-#define USB_PID_DATA2           0x87
-#define USB_PID_MDATA           0x0f
-/* Special */
-#define USB_PID_PREAMBLE        0x3c
-#define USB_PID_ERR             0x3c
-#define USB_PID_SPLIT           0x78
-#define USB_PID_PING            0xb4
-#define USB_PID_UNDEF_0         0xf0
-
-#define USB_PID_DATA_TOGGLE     0x88
-#define DBGP_CLAIM (DBGP_OWNER | DBGP_ENABLED | DBGP_INUSE)
-
-#define PCI_CAP_ID_EHCI_DEBUG   0xa
-
-#define HUB_ROOT_RESET_TIME     50      /* times are in msec */
-#define HUB_SHORT_RESET_TIME    10
-#define HUB_LONG_RESET_TIME     200
-#define HUB_RESET_TIMEOUT       500
-
-#define DBGP_MAX_PACKET         8
-
-static int dbgp_wait_until_complete(void)
-{
-        u32 ctrl;
-        int loop = 0x100000;
-
-        do {
-                ctrl = readl(&ehci_debug->control);
-                /* Stop when the transaction is finished */
-                if (ctrl & DBGP_DONE)
-                        break;
-        } while (--loop > 0);
-
-        if (!loop)
-                return -1;
-
-        /*
-         * Now that we have observed the completed transaction,
-         * clear the done bit.
-         */
-        writel(ctrl | DBGP_DONE, &ehci_debug->control);
-        return (ctrl & DBGP_ERROR) ? -DBGP_ERRCODE(ctrl) : DBGP_LEN(ctrl);
-}
-
-static void __init dbgp_mdelay(int ms)
-{
-        int i;
-
-        while (ms--) {
-                for (i = 0; i < 1000; i++)
-                        outb(0x1, 0x80);
-        }
-}
-
-static void dbgp_breath(void)
-{
-        /* Sleep to give the debug port a chance to breathe */
-}
-
-static int dbgp_wait_until_done(unsigned ctrl)
-{
-        u32 pids, lpid;
-        int ret;
-        int loop = 3;
-
-retry:
-        writel(ctrl | DBGP_GO, &ehci_debug->control);
-        ret = dbgp_wait_until_complete();
-        pids = readl(&ehci_debug->pids);
-        lpid = DBGP_PID_GET(pids);
-
-        if (ret < 0)
-                return ret;
-
-        /*
-         * If the port is getting full or it has dropped data
-         * start pacing ourselves, not necessary but it's friendly.
-         */
-        if ((lpid == USB_PID_NAK) || (lpid == USB_PID_NYET))
-                dbgp_breath();
-
-        /* If I get a NACK reissue the transmission */
-        if (lpid == USB_PID_NAK) {
-                if (--loop > 0)
-                        goto retry;
-        }
-
-        return ret;
-}
-
-static void dbgp_set_data(const void *buf, int size)
-{
-        const unsigned char *bytes = buf;
-        u32 lo, hi;
-        int i;
-
-        lo = hi = 0;
-        for (i = 0; i < 4 && i < size; i++)
-                lo |= bytes[i] << (8*i);
-        for (; i < 8 && i < size; i++)
-                hi |= bytes[i] << (8*(i - 4));
-        writel(lo, &ehci_debug->data03);
-        writel(hi, &ehci_debug->data47);
-}
-
-static void __init dbgp_get_data(void *buf, int size)
-{
-        unsigned char *bytes = buf;
-        u32 lo, hi;
-        int i;
-
-        lo = readl(&ehci_debug->data03);
-        hi = readl(&ehci_debug->data47);
-        for (i = 0; i < 4 && i < size; i++)
-                bytes[i] = (lo >> (8*i)) & 0xff;
-        for (; i < 8 && i < size; i++)
-                bytes[i] = (hi >> (8*(i - 4))) & 0xff;
-}
-
-static int dbgp_bulk_write(unsigned devnum, unsigned endpoint,
-                         const char *bytes, int size)
-{
-        u32 pids, addr, ctrl;
-        int ret;
-
-        if (size > DBGP_MAX_PACKET)
-                return -1;
-
-        addr = DBGP_EPADDR(devnum, endpoint);
-
-        pids = readl(&ehci_debug->pids);
-        pids = dbgp_pid_update(pids, USB_PID_OUT);
-
-        ctrl = readl(&ehci_debug->control);
-        ctrl = dbgp_len_update(ctrl, size);
-        ctrl |= DBGP_OUT;
-        ctrl |= DBGP_GO;
-
-        dbgp_set_data(bytes, size);
-        writel(addr, &ehci_debug->address);
-        writel(pids, &ehci_debug->pids);
-
-        ret = dbgp_wait_until_done(ctrl);
-        if (ret < 0)
-                return ret;
-
-        return ret;
-}
-
-static int __init dbgp_bulk_read(unsigned devnum, unsigned endpoint, void *data,
-                                 int size)
-{
-        u32 pids, addr, ctrl;
-        int ret;
-
-        if (size > DBGP_MAX_PACKET)
-                return -1;
-
-        addr = DBGP_EPADDR(devnum, endpoint);
-
-        pids = readl(&ehci_debug->pids);
-        pids = dbgp_pid_update(pids, USB_PID_IN);
-
-        ctrl = readl(&ehci_debug->control);
-        ctrl = dbgp_len_update(ctrl, size);
-        ctrl &= ~DBGP_OUT;
-        ctrl |= DBGP_GO;
-
-        writel(addr, &ehci_debug->address);
-        writel(pids, &ehci_debug->pids);
-        ret = dbgp_wait_until_done(ctrl);
-        if (ret < 0)
-                return ret;
-
-        if (size > ret)
-                size = ret;
-        dbgp_get_data(data, size);
-        return ret;
-}
-
-static int __init dbgp_control_msg(unsigned devnum, int requesttype,
-        int request, int value, int index, void *data, int size)
-{
-        u32 pids, addr, ctrl;
-        struct usb_ctrlrequest req;
-        int read;
-        int ret;
-
-        read = (requesttype & USB_DIR_IN) != 0;
-        if (size > (read ? DBGP_MAX_PACKET:0))
-                return -1;
-
-        /* Compute the control message */
-        req.bRequestType = requesttype;
-        req.bRequest = request;
-        req.wValue = cpu_to_le16(value);
-        req.wIndex = cpu_to_le16(index);
-        req.wLength = cpu_to_le16(size);
-
-        pids = DBGP_PID_SET(USB_PID_DATA0, USB_PID_SETUP);
-        addr = DBGP_EPADDR(devnum, 0);
-
-        ctrl = readl(&ehci_debug->control);
-        ctrl = dbgp_len_update(ctrl, sizeof(req));
-        ctrl |= DBGP_OUT;
-        ctrl |= DBGP_GO;
-
-        /* Send the setup message */
-        dbgp_set_data(&req, sizeof(req));
-        writel(addr, &ehci_debug->address);
-        writel(pids, &ehci_debug->pids);
-        ret = dbgp_wait_until_done(ctrl);
-        if (ret < 0)
-                return ret;
-
-        /* Read the result */
-        return dbgp_bulk_read(devnum, 0, data, size);
-}
-
-
-/* Find a PCI capability */
-static u32 __init find_cap(u32 num, u32 slot, u32 func, int cap)
-{
-        u8 pos;
-        int bytes;
-
-        if (!(read_pci_config_16(num, slot, func, PCI_STATUS) &
-                PCI_STATUS_CAP_LIST))
-                return 0;
-
-        pos = read_pci_config_byte(num, slot, func, PCI_CAPABILITY_LIST);
-        for (bytes = 0; bytes < 48 && pos >= 0x40; bytes++) {
-                u8 id;
-
-                pos &= ~3;
-                id = read_pci_config_byte(num, slot, func, pos+PCI_CAP_LIST_ID);
-                if (id == 0xff)
-                        break;
-                if (id == cap)
-                        return pos;
-
-                pos = read_pci_config_byte(num, slot, func,
-                                                 pos+PCI_CAP_LIST_NEXT);
-        }
-        return 0;
-}
-
-static u32 __init __find_dbgp(u32 bus, u32 slot, u32 func)
-{
-        u32 class;
-
-        class = read_pci_config(bus, slot, func, PCI_CLASS_REVISION);
-        if ((class >> 8) != PCI_CLASS_SERIAL_USB_EHCI)
-                return 0;
-
-        return find_cap(bus, slot, func, PCI_CAP_ID_EHCI_DEBUG);
-}
-
-static u32 __init find_dbgp(int ehci_num, u32 *rbus, u32 *rslot, u32 *rfunc)
-{
-        u32 bus, slot, func;
-
-        for (bus = 0; bus < 256; bus++) {
-                for (slot = 0; slot < 32; slot++) {
-                        for (func = 0; func < 8; func++) {
-                                unsigned cap;
-
-                                cap = __find_dbgp(bus, slot, func);
-
-                                if (!cap)
-                                        continue;
-                                if (ehci_num-- != 0)
-                                        continue;
-                                *rbus = bus;
-                                *rslot = slot;
-                                *rfunc = func;
-                                return cap;
-                        }
-                }
-        }
-        return 0;
-}
-
-static int __init ehci_reset_port(int port)
-{
-        u32 portsc;
-        u32 delay_time, delay;
-        int loop;
-
-        /* Reset the usb debug port */
-        portsc = readl(&ehci_regs->port_status[port - 1]);
-        portsc &= ~PORT_PE;
-        portsc |= PORT_RESET;
-        writel(portsc, &ehci_regs->port_status[port - 1]);
-
-        delay = HUB_ROOT_RESET_TIME;
-        for (delay_time = 0; delay_time < HUB_RESET_TIMEOUT;
-             delay_time += delay) {
-                dbgp_mdelay(delay);
-
-                portsc = readl(&ehci_regs->port_status[port - 1]);
-                if (portsc & PORT_RESET) {
-                        /* force reset to complete */
-                        loop = 2;
-                        writel(portsc & ~(PORT_RWC_BITS | PORT_RESET),
-                                &ehci_regs->port_status[port - 1]);
-                        do {
-                                portsc = readl(&ehci_regs->port_status[port-1]);
-                        } while ((portsc & PORT_RESET) && (--loop > 0));
-                }
-
-                /* Device went away? */
-                if (!(portsc & PORT_CONNECT))
-                        return -ENOTCONN;
-
-                /* bomb out completely if something weird happend */
-                if ((portsc & PORT_CSC))
-                        return -EINVAL;
-
-                /* If we've finished resetting, then break out of the loop */
-                if (!(portsc & PORT_RESET) && (portsc & PORT_PE))
-                        return 0;
-        }
-        return -EBUSY;
-}
-
-static int __init ehci_wait_for_port(int port)
-{
-        u32 status;
-        int ret, reps;
-
-        for (reps = 0; reps < 3; reps++) {
-                dbgp_mdelay(100);
-                status = readl(&ehci_regs->status);
-                if (status & STS_PCD) {
-                        ret = ehci_reset_port(port);
-                        if (ret == 0)
-                                return 0;
-                }
-        }
-        return -ENOTCONN;
-}
-
-#ifdef DBGP_DEBUG
-# define dbgp_printk early_printk
-#else
-static inline void dbgp_printk(const char *fmt, ...) { }
-#endif
-
-typedef void (*set_debug_port_t)(int port);
-
-static void __init default_set_debug_port(int port)
-{
-}
-
-static set_debug_port_t __initdata set_debug_port = default_set_debug_port;
-
-static void __init nvidia_set_debug_port(int port)
-{
-        u32 dword;
-        dword = read_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func,
-                                 0x74);
-        dword &= ~(0x0f<<12);
-        dword |= ((port & 0x0f)<<12);
-        write_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func, 0x74,
-                                 dword);
-        dbgp_printk("set debug port to %d\n", port);
-}
-
-static void __init detect_set_debug_port(void)
-{
-        u32 vendorid;
-
-        vendorid = read_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func,
-                 0x00);
-
-        if ((vendorid & 0xffff) == 0x10de) {
-                dbgp_printk("using nvidia set_debug_port\n");
-                set_debug_port = nvidia_set_debug_port;
-        }
-}
-
-static int __init ehci_setup(void)
-{
-        struct usb_debug_descriptor dbgp_desc;
-        u32 cmd, ctrl, status, portsc, hcs_params;
-        u32 debug_port, new_debug_port = 0, n_ports;
-        u32  devnum;
-        int ret, i;
-        int loop;
-        int port_map_tried;
-        int playtimes = 3;
-
-try_next_time:
-        port_map_tried = 0;
-
-try_next_port:
-
-        hcs_params = readl(&ehci_caps->hcs_params);
-        debug_port = HCS_DEBUG_PORT(hcs_params);
-        n_ports    = HCS_N_PORTS(hcs_params);
-
-        dbgp_printk("debug_port: %d\n", debug_port);
-        dbgp_printk("n_ports:    %d\n", n_ports);
-
-        for (i = 1; i <= n_ports; i++) {
-                portsc = readl(&ehci_regs->port_status[i-1]);
-                dbgp_printk("portstatus%d: %08x\n", i, portsc);
-        }
-
-        if (port_map_tried && (new_debug_port != debug_port)) {
-                if (--playtimes) {
-                        set_debug_port(new_debug_port);
-                        goto try_next_time;
-                }
-                return -1;
-        }
-
-        loop = 100000;
-        /* Reset the EHCI controller */
-        cmd = readl(&ehci_regs->command);
-        cmd |= CMD_RESET;
-        writel(cmd, &ehci_regs->command);
-        do {
-                cmd = readl(&ehci_regs->command);
-        } while ((cmd & CMD_RESET) && (--loop > 0));
-
-        if (!loop) {
-                dbgp_printk("can not reset ehci\n");
-                return -1;
-        }
-        dbgp_printk("ehci reset done\n");
-
-        /* Claim ownership, but do not enable yet */
-        ctrl = readl(&ehci_debug->control);
-        ctrl |= DBGP_OWNER;
-        ctrl &= ~(DBGP_ENABLED | DBGP_INUSE);
-        writel(ctrl, &ehci_debug->control);
-
-        /* Start the ehci running */
-        cmd = readl(&ehci_regs->command);
-        cmd &= ~(CMD_LRESET | CMD_IAAD | CMD_PSE | CMD_ASE | CMD_RESET);
-        cmd |= CMD_RUN;
-        writel(cmd, &ehci_regs->command);
-
-        /* Ensure everything is routed to the EHCI */
-        writel(FLAG_CF, &ehci_regs->configured_flag);
-
-        /* Wait until the controller is no longer halted */
-        loop = 10;
-        do {
-                status = readl(&ehci_regs->status);
-        } while ((status & STS_HALT) && (--loop > 0));
-
-        if (!loop) {
-                dbgp_printk("ehci can be started\n");
-                return -1;
-        }
-        dbgp_printk("ehci started\n");
-
-        /* Wait for a device to show up in the debug port */
-        ret = ehci_wait_for_port(debug_port);
-        if (ret < 0) {
-                dbgp_printk("No device found in debug port\n");
-                goto next_debug_port;
-        }
-        dbgp_printk("ehci wait for port done\n");
-
-        /* Enable the debug port */
-        ctrl = readl(&ehci_debug->control);
-        ctrl |= DBGP_CLAIM;
-        writel(ctrl, &ehci_debug->control);
-        ctrl = readl(&ehci_debug->control);
-        if ((ctrl & DBGP_CLAIM) != DBGP_CLAIM) {
-                dbgp_printk("No device in debug port\n");
-                writel(ctrl & ~DBGP_CLAIM, &ehci_debug->control);
-                goto err;
-        }
-        dbgp_printk("debug ported enabled\n");
-
-        /* Completely transfer the debug device to the debug controller */
-        portsc = readl(&ehci_regs->port_status[debug_port - 1]);
-        portsc &= ~PORT_PE;
-        writel(portsc, &ehci_regs->port_status[debug_port - 1]);
-
-        dbgp_mdelay(100);
-
-        /* Find the debug device and make it device number 127 */
-        for (devnum = 0; devnum <= 127; devnum++) {
-                ret = dbgp_control_msg(devnum,
-                        USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
-                        USB_REQ_GET_DESCRIPTOR, (USB_DT_DEBUG << 8), 0,
-                        &dbgp_desc, sizeof(dbgp_desc));
-                if (ret > 0)
-                        break;
-        }
-        if (devnum > 127) {
-                dbgp_printk("Could not find attached debug device\n");
-                goto err;
-        }
-        if (ret < 0) {
-                dbgp_printk("Attached device is not a debug device\n");
-                goto err;
-        }
-        dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint;
-
-        /* Move the device to 127 if it isn't already there */
-        if (devnum != USB_DEBUG_DEVNUM) {
-                ret = dbgp_control_msg(devnum,
-                        USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
-                        USB_REQ_SET_ADDRESS, USB_DEBUG_DEVNUM, 0, NULL, 0);
-                if (ret < 0) {
-                        dbgp_printk("Could not move attached device to %d\n",
-                                USB_DEBUG_DEVNUM);
-                        goto err;
-                }
-                devnum = USB_DEBUG_DEVNUM;
-                dbgp_printk("debug device renamed to 127\n");
-        }
-
-        /* Enable the debug interface */
-        ret = dbgp_control_msg(USB_DEBUG_DEVNUM,
-                USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
-                USB_REQ_SET_FEATURE, USB_DEVICE_DEBUG_MODE, 0, NULL, 0);
-        if (ret < 0) {
-                dbgp_printk(" Could not enable the debug device\n");
-                goto err;
-        }
-        dbgp_printk("debug interface enabled\n");
-
-        /* Perform a small write to get the even/odd data state in sync
-         */
-        ret = dbgp_bulk_write(USB_DEBUG_DEVNUM, dbgp_endpoint_out, " ", 1);
-        if (ret < 0) {
-                dbgp_printk("dbgp_bulk_write failed: %d\n", ret);
-                goto err;
-        }
-        dbgp_printk("small write doned\n");
-
-        return 0;
-err:
-        /* Things didn't work so remove my claim */
-        ctrl = readl(&ehci_debug->control);
-        ctrl &= ~(DBGP_CLAIM | DBGP_OUT);
-        writel(ctrl, &ehci_debug->control);
-        return -1;
-
-next_debug_port:
-        port_map_tried |= (1<<(debug_port - 1));
-        new_debug_port = ((debug_port-1+1)%n_ports) + 1;
-        if (port_map_tried != ((1<<n_ports) - 1)) {
-                set_debug_port(new_debug_port);
-                goto try_next_port;
-        }
-        if (--playtimes) {
-                set_debug_port(new_debug_port);
-                goto try_next_time;
-        }
-
-        return -1;
-}
-
-static int __init early_dbgp_init(char *s)
-{
-        u32 debug_port, bar, offset;
-        u32 bus, slot, func, cap;
-        void __iomem *ehci_bar;
-        u32 dbgp_num;
-        u32 bar_val;
-        char *e;
-        int ret;
-        u8 byte;
-
-        if (!early_pci_allowed())
-                return -1;
-
-        dbgp_num = 0;
-        if (*s)
-                dbgp_num = simple_strtoul(s, &e, 10);
-        dbgp_printk("dbgp_num: %d\n", dbgp_num);
-
-        cap = find_dbgp(dbgp_num, &bus, &slot, &func);
-        if (!cap)
-                return -1;
-
-        dbgp_printk("Found EHCI debug port on %02x:%02x.%1x\n", bus, slot,
-                         func);
-
-        debug_port = read_pci_config(bus, slot, func, cap);
-        bar = (debug_port >> 29) & 0x7;
-        bar = (bar * 4) + 0xc;
-        offset = (debug_port >> 16) & 0xfff;
-        dbgp_printk("bar: %02x offset: %03x\n", bar, offset);
-        if (bar != PCI_BASE_ADDRESS_0) {
-                dbgp_printk("only debug ports on bar 1 handled.\n");
-
-                return -1;
-        }
-
-        bar_val = read_pci_config(bus, slot, func, PCI_BASE_ADDRESS_0);
-        dbgp_printk("bar_val: %02x offset: %03x\n", bar_val, offset);
-        if (bar_val & ~PCI_BASE_ADDRESS_MEM_MASK) {
-                dbgp_printk("only simple 32bit mmio bars supported\n");
-
-                return -1;
-        }
-
-        /* double check if the mem space is enabled */
-        byte = read_pci_config_byte(bus, slot, func, 0x04);
-        if (!(byte & 0x2)) {
-                byte  |= 0x02;
-                write_pci_config_byte(bus, slot, func, 0x04, byte);
-                dbgp_printk("mmio for ehci enabled\n");
-        }
-
-        /*
-         * FIXME I don't have the bar size so just guess PAGE_SIZE is more
-         * than enough.  1K is the biggest I have seen.
-         */
-        set_fixmap_nocache(FIX_DBGP_BASE, bar_val & PAGE_MASK);
-        ehci_bar = (void __iomem *)__fix_to_virt(FIX_DBGP_BASE);
-        ehci_bar += bar_val & ~PAGE_MASK;
-        dbgp_printk("ehci_bar: %p\n", ehci_bar);
-
-        ehci_caps  = ehci_bar;
-        ehci_regs  = ehci_bar + HC_LENGTH(readl(&ehci_caps->hc_capbase));
-        ehci_debug = ehci_bar + offset;
-        ehci_dev.bus = bus;
-        ehci_dev.slot = slot;
-        ehci_dev.func = func;
-
-        detect_set_debug_port();
-
-        ret = ehci_setup();
-        if (ret < 0) {
-                dbgp_printk("ehci_setup failed\n");
-                ehci_debug = NULL;
-
-                return -1;
-        }
-
-        return 0;
-}
-
-static void early_dbgp_write(struct console *con, const char *str, u32 n)
-{
-        int chunk, ret;
-
-        if (!ehci_debug)
-                return;
-        while (n > 0) {
-                chunk = n;
-                if (chunk > DBGP_MAX_PACKET)
-                        chunk = DBGP_MAX_PACKET;
-                ret = dbgp_bulk_write(USB_DEBUG_DEVNUM,
-                        dbgp_endpoint_out, str, chunk);
-                str += chunk;
-                n -= chunk;
-        }
-}
-
-static struct console early_dbgp_console = {
-        .name =         "earlydbg",
-        .write =        early_dbgp_write,
-        .flags =        CON_PRINTBUFFER,
-        .index =        -1,
-};
-#endif
-
 /* Direct interface for emergencies */
 static struct console *early_console = &early_vga_console;
 static int __initdata early_console_initialized;
@@ -891,10 +176,19 @@ asmlinkage void early_printk(const char *fmt, ...)
         va_end(ap);
 }
 
+static inline void early_console_register(struct console *con, int keep_early)
+{
+        early_console = con;
+        if (keep_early)
+                early_console->flags &= ~CON_BOOT;
+        else
+                early_console->flags |= CON_BOOT;
+        register_console(early_console);
+}
 
 static int __init setup_early_printk(char *buf)
 {
-        int keep_early;
+        int keep;
 
         if (!buf)
                 return 0;
@@ -903,42 +197,34 @@ static int __init setup_early_printk(char *buf)
                 return 0;
         early_console_initialized = 1;
 
-        keep_early = (strstr(buf, "keep") != NULL);
-
-        if (!strncmp(buf, "serial", 6)) {
-                early_serial_init(buf + 6);
-                early_console = &early_serial_console;
-        } else if (!strncmp(buf, "ttyS", 4)) {
-                early_serial_init(buf);
-                early_console = &early_serial_console;
-        } else if (!strncmp(buf, "vga", 3)
-                && boot_params.screen_info.orig_video_isVGA == 1) {
-                max_xpos = boot_params.screen_info.orig_video_cols;
-                max_ypos = boot_params.screen_info.orig_video_lines;
-                current_ypos = boot_params.screen_info.orig_y;
-                early_console = &early_vga_console;
+        keep = (strstr(buf, "keep") != NULL);
+
+        while (*buf != '\0') {
+                if (!strncmp(buf, "serial", 6)) {
+                        early_serial_init(buf + 6);
+                        early_console_register(&early_serial_console, keep);
+                }
+                if (!strncmp(buf, "ttyS", 4)) {
+                        early_serial_init(buf + 4);
+                        early_console_register(&early_serial_console, keep);
+                }
+                if (!strncmp(buf, "vga", 3) &&
+                    boot_params.screen_info.orig_video_isVGA == 1) {
+                        max_xpos = boot_params.screen_info.orig_video_cols;
+                        max_ypos = boot_params.screen_info.orig_video_lines;
+                        current_ypos = boot_params.screen_info.orig_y;
+                        early_console_register(&early_vga_console, keep);
+                }
 #ifdef CONFIG_EARLY_PRINTK_DBGP
-        } else if (!strncmp(buf, "dbgp", 4)) {
-                if (early_dbgp_init(buf+4) < 0)
-                        return 0;
-                early_console = &early_dbgp_console;
-                /*
-                 * usb subsys will reset ehci controller, so don't keep
-                 * that early console
-                 */
-                keep_early = 0;
+                if (!strncmp(buf, "dbgp", 4) && !early_dbgp_init(buf + 4))
+                        early_console_register(&early_dbgp_console, keep);
 #endif
 #ifdef CONFIG_HVC_XEN
-        } else if (!strncmp(buf, "xen", 3)) {
-                early_console = &xenboot_console;
+                if (!strncmp(buf, "xen", 3))
+                        early_console_register(&xenboot_console, keep);
 #endif
+                buf++;
         }
-
-        if (keep_early)
-                early_console->flags &= ~CON_BOOT;
-        else
-                early_console->flags |= CON_BOOT;
-        register_console(early_console);
         return 0;
 }
 
diff --git a/drivers/net/usb/cdc_eem.c b/drivers/net/usb/cdc_eem.c
index 45cebfb302cf..23300656c266 100644
--- a/drivers/net/usb/cdc_eem.c
+++ b/drivers/net/usb/cdc_eem.c
@@ -300,20 +300,23 @@ static int eem_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                                         return 0;
                         }
 
-                        crc = get_unaligned_le32(skb2->data
-                                        + len - ETH_FCS_LEN);
-                        skb_trim(skb2, len - ETH_FCS_LEN);
-
                         /*
                          * The bmCRC helps to denote when the CRC field in
                          * the Ethernet frame contains a calculated CRC:
                          *      bmCRC = 1       : CRC is calculated
                          *      bmCRC = 0       : CRC = 0xDEADBEEF
                          */
-                        if (header & BIT(14))
-                                crc2 = ~crc32_le(~0, skb2->data, skb2->len);
-                        else
+                        if (header & BIT(14)) {
+                                crc = get_unaligned_le32(skb2->data
+                                                + len - ETH_FCS_LEN);
+                                crc2 = ~crc32_le(~0, skb2->data, skb2->len
+                                                - ETH_FCS_LEN);
+                        } else {
+                                crc = get_unaligned_be32(skb2->data
+                                                + len - ETH_FCS_LEN);
                                 crc2 = 0xdeadbeef;
+                        }
+                        skb_trim(skb2, len - ETH_FCS_LEN);
 
                         if (is_last)
                                 return crc == crc2;
diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index dcd49f1e96d0..ebd7237230e3 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -39,6 +39,7 @@ config USB_ARCH_HAS_OHCI
         default y if ARCH_AT91
         default y if ARCH_PNX4008 && I2C
         default y if MFD_TC6393XB
+        default y if ARCH_W90X900
         # PPC:
         default y if STB03xxx
         default y if PPC_MPC52xx
@@ -58,6 +59,8 @@ config USB_ARCH_HAS_EHCI
         default y if PPC_83xx
         default y if SOC_AU1200
         default y if ARCH_IXP4XX
+        default y if ARCH_W90X900
+        default y if ARCH_AT91SAM9G45
         default PCI
 
 # ARM SA1111 chips have a non-PCI based "OHCI-compatible" USB host interface.
diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index 19cb7d5480d7..be3c9b80bc9f 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -16,6 +16,7 @@ obj-$(CONFIG_USB_UHCI_HCD)	+= host/
 obj-$(CONFIG_USB_FHCI_HCD)      += host/
 obj-$(CONFIG_USB_XHCI_HCD)      += host/
 obj-$(CONFIG_USB_SL811_HCD)     += host/
+obj-$(CONFIG_USB_ISP1362_HCD)   += host/
 obj-$(CONFIG_USB_U132_HCD)      += host/
 obj-$(CONFIG_USB_R8A66597_HCD)  += host/
 obj-$(CONFIG_USB_HWA_HCD)       += host/
@@ -39,6 +40,7 @@ obj-$(CONFIG_USB_MICROTEK)	+= image/
 obj-$(CONFIG_USB_SERIAL)        += serial/
 
 obj-$(CONFIG_USB)               += misc/
+obj-y                           += early/
 
 obj-$(CONFIG_USB_ATM)           += atm/
 obj-$(CONFIG_USB_SPEEDTOUCH)    += atm/
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 85a1a55815cf..e3861b21e776 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -59,6 +59,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
+#include <linux/serial.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
@@ -609,6 +610,7 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         acm->throttle = 0;
 
         tasklet_schedule(&acm->urb_task);
+        set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
         rv = tty_port_block_til_ready(&acm->port, tty, filp);
 done:
         mutex_unlock(&acm->mutex);
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index 8c64c018b676..3e564bfe17d1 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -313,8 +313,13 @@ static ssize_t wdm_write
         r = usb_autopm_get_interface(desc->intf);
         if (r < 0)
                 goto outnp;
-        r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
-                                                           &desc->flags));
+
+        if (!file->f_flags && O_NONBLOCK)
+                r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
+                                                                &desc->flags));
+        else
+                if (test_bit(WDM_IN_USE, &desc->flags))
+                        r = -EAGAIN;
         if (r < 0)
                 goto out;
 
@@ -377,7 +382,7 @@ outnl:
 static ssize_t wdm_read
 (struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
-        int rv, cntr;
+        int rv, cntr = 0;
         int i = 0;
         struct wdm_device *desc = file->private_data;
 
@@ -389,10 +394,23 @@ static ssize_t wdm_read
         if (desc->length == 0) {
                 desc->read = 0;
 retry:
+                if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
+                        rv = -ENODEV;
+                        goto err;
+                }
                 i++;
-                rv = wait_event_interruptible(desc->wait,
-                                              test_bit(WDM_READ, &desc->flags));
+                if (file->f_flags & O_NONBLOCK) {
+                        if (!test_bit(WDM_READ, &desc->flags)) {
+                                rv = cntr ? cntr : -EAGAIN;
+                                goto err;
+                        }
+                        rv = 0;
+                } else {
+                        rv = wait_event_interruptible(desc->wait,
+                                test_bit(WDM_READ, &desc->flags));
+                }
 
+                /* may have happened while we slept */
                 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
                         rv = -ENODEV;
                         goto err;
@@ -448,7 +466,7 @@ retry:
 
 err:
         mutex_unlock(&desc->rlock);
-        if (rv < 0)
+        if (rv < 0 && rv != -EAGAIN)
                 dev_err(&desc->intf->dev, "wdm_read: exit error\n");
         return rv;
 }
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c
index b09a527f7341..333ee02e7b2b 100644
--- a/drivers/usb/class/usbtmc.c
+++ b/drivers/usb/class/usbtmc.c
@@ -57,7 +57,9 @@ MODULE_DEVICE_TABLE(usb, usbtmc_devices);
 
 /*
  * This structure is the capabilities for the device
- * See section 4.2.1.8 of the USBTMC specification for details.
+ * See section 4.2.1.8 of the USBTMC specification,
+ * and section 4.2.2 of the USBTMC usb488 subclass
+ * specification for details.
  */
 struct usbtmc_dev_capabilities {
         __u8 interface_capabilities;
@@ -86,6 +88,8 @@ struct usbtmc_device_data {
         bool TermCharEnabled;
         bool auto_abort;
 
+        bool zombie; /* fd of disconnected device */
+
         struct usbtmc_dev_capabilities  capabilities;
         struct kref kref;
         struct mutex io_mutex;  /* only one i/o function running at a time */
@@ -367,13 +371,13 @@ static ssize_t usbtmc_read(struct file *filp, char __user *buf,
 {
         struct usbtmc_device_data *data;
         struct device *dev;
-        unsigned long int n_characters;
+        u32 n_characters;
         u8 *buffer;
         int actual;
-        int done;
-        int remaining;
+        size_t done;
+        size_t remaining;
         int retval;
-        int this_part;
+        size_t this_part;
 
         /* Get pointer to private data structure */
         data = filp->private_data;
@@ -384,6 +388,10 @@ static ssize_t usbtmc_read(struct file *filp, char __user *buf,
                 return -ENOMEM;
 
         mutex_lock(&data->io_mutex);
+        if (data->zombie) {
+                retval = -ENODEV;
+                goto exit;
+        }
 
         remaining = count;
         done = 0;
@@ -401,10 +409,10 @@ static ssize_t usbtmc_read(struct file *filp, char __user *buf,
                 buffer[1] = data->bTag;
                 buffer[2] = ~(data->bTag);
                 buffer[3] = 0; /* Reserved */
-                buffer[4] = (this_part - 12 - 3) & 255;
-                buffer[5] = ((this_part - 12 - 3) >> 8) & 255;
-                buffer[6] = ((this_part - 12 - 3) >> 16) & 255;
-                buffer[7] = ((this_part - 12 - 3) >> 24) & 255;
+                buffer[4] = (this_part) & 255;
+                buffer[5] = ((this_part) >> 8) & 255;
+                buffer[6] = ((this_part) >> 16) & 255;
+                buffer[7] = ((this_part) >> 24) & 255;
                 buffer[8] = data->TermCharEnabled * 2;
                 /* Use term character? */
                 buffer[9] = data->TermChar;
@@ -455,6 +463,22 @@ static ssize_t usbtmc_read(struct file *filp, char __user *buf,
                                (buffer[6] << 16) +
                                (buffer[7] << 24);
 
+                /* Ensure the instrument doesn't lie about it */
+                if(n_characters > actual - 12) {
+                        dev_err(dev, "Device lies about message size: %u > %d\n", n_characters, actual - 12);
+                        n_characters = actual - 12;
+                }
+
+                /* Ensure the instrument doesn't send more back than requested */
+                if(n_characters > this_part) {
+                        dev_err(dev, "Device returns more than requested: %zu > %zu\n", done + n_characters, done + this_part);
+                        n_characters = this_part;
+                }
+
+                /* Bound amount of data received by amount of data requested */
+                if (n_characters > this_part)
+                        n_characters = this_part;
+
                 /* Copy buffer to user space */
                 if (copy_to_user(buf + done, &buffer[12], n_characters)) {
                         /* There must have been an addressing problem */
@@ -463,8 +487,11 @@ static ssize_t usbtmc_read(struct file *filp, char __user *buf,
                 }
 
                 done += n_characters;
-                if (n_characters < USBTMC_SIZE_IOBUFFER)
+                /* Terminate if end-of-message bit recieved from device */
+                if ((buffer[8] &  0x01) && (actual >= n_characters + 12))
                         remaining = 0;
+                else
+                        remaining -= n_characters;
         }
 
         /* Update file position value */
@@ -496,6 +523,10 @@ static ssize_t usbtmc_write(struct file *filp, const char __user *buf,
                 return -ENOMEM;
 
         mutex_lock(&data->io_mutex);
+        if (data->zombie) {
+                retval = -ENODEV;
+                goto exit;
+        }
 
         remaining = count;
         done = 0;
@@ -767,20 +798,21 @@ static int get_capabilities(struct usbtmc_device_data *data)
         }
 
         dev_dbg(dev, "GET_CAPABILITIES returned %x\n", buffer[0]);
-        dev_dbg(dev, "Interface capabilities are %x\n", buffer[4]);
-        dev_dbg(dev, "Device capabilities are %x\n", buffer[5]);
-        dev_dbg(dev, "USB488 interface capabilities are %x\n", buffer[14]);
-        dev_dbg(dev, "USB488 device capabilities are %x\n", buffer[15]);
         if (buffer[0] != USBTMC_STATUS_SUCCESS) {
                 dev_err(dev, "GET_CAPABILITIES returned %x\n", buffer[0]);
                 rv = -EPERM;
                 goto err_out;
         }
+        dev_dbg(dev, "Interface capabilities are %x\n", buffer[4]);
+        dev_dbg(dev, "Device capabilities are %x\n", buffer[5]);
+        dev_dbg(dev, "USB488 interface capabilities are %x\n", buffer[14]);
+        dev_dbg(dev, "USB488 device capabilities are %x\n", buffer[15]);
 
         data->capabilities.interface_capabilities = buffer[4];
         data->capabilities.device_capabilities = buffer[5];
         data->capabilities.usb488_interface_capabilities = buffer[14];
         data->capabilities.usb488_device_capabilities = buffer[15];
+        rv = 0;
 
 err_out:
         kfree(buffer);
@@ -925,6 +957,10 @@ static long usbtmc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
         data = file->private_data;
         mutex_lock(&data->io_mutex);
+        if (data->zombie) {
+                retval = -ENODEV;
+                goto skip_io_on_zombie;
+        }
 
         switch (cmd) {
         case USBTMC_IOCTL_CLEAR_OUT_HALT:
@@ -952,6 +988,7 @@ static long usbtmc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 break;
         }
 
+skip_io_on_zombie:
         mutex_unlock(&data->io_mutex);
         return retval;
 }
@@ -995,6 +1032,7 @@ static int usbtmc_probe(struct usb_interface *intf,
         usb_set_intfdata(intf, data);
         kref_init(&data->kref);
         mutex_init(&data->io_mutex);
+        data->zombie = 0;
 
         /* Initialize USBTMC bTag and other fields */
         data->bTag      = 1;
@@ -1065,14 +1103,30 @@ static void usbtmc_disconnect(struct usb_interface *intf)
         usb_deregister_dev(intf, &usbtmc_class);
         sysfs_remove_group(&intf->dev.kobj, &capability_attr_grp);
         sysfs_remove_group(&intf->dev.kobj, &data_attr_grp);
+        mutex_lock(&data->io_mutex);
+        data->zombie = 1;
+        mutex_unlock(&data->io_mutex);
         kref_put(&data->kref, usbtmc_delete);
 }
 
+static int usbtmc_suspend (struct usb_interface *intf, pm_message_t message)
+{
+        /* this driver does not have pending URBs */
+        return 0;
+}
+
+static int usbtmc_resume (struct usb_interface *intf)
+{
+        return 0;
+}
+
 static struct usb_driver usbtmc_driver = {
         .name           = "usbtmc",
         .id_table       = usbtmc_devices,
         .probe          = usbtmc_probe,
-        .disconnect     = usbtmc_disconnect
+        .disconnect     = usbtmc_disconnect,
+        .suspend        = usbtmc_suspend,
+        .resume         = usbtmc_resume,
 };
 
 static int __init usbtmc_init(void)
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index a16c538d0132..0d3af6a6ee49 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -105,7 +105,7 @@ static int usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
         ep->ss_ep_comp->extralen = i;
         buffer += i;
         size -= i;
-        retval = buffer - buffer_start + i;
+        retval = buffer - buffer_start;
         if (num_skipped > 0)
                 dev_dbg(ddev, "skipped %d descriptor%s after %s\n",
                                 num_skipped, plural(num_skipped),
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 4247eccf858c..181f78c84105 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -52,6 +52,7 @@
 
 #include "hcd.h"        /* for usbcore internals */
 #include "usb.h"
+#include "hub.h"
 
 #define USB_MAXBUS                      64
 #define USB_DEVICE_MAX                  USB_MAXBUS * 128
@@ -73,6 +74,7 @@ struct dev_state {
         void __user *disccontext;
         unsigned long ifclaimed;
         u32 secid;
+        u32 disabled_bulk_eps;
 };
 
 struct async {
@@ -87,6 +89,8 @@ struct async {
         struct urb *urb;
         int status;
         u32 secid;
+        u8 bulk_addr;
+        u8 bulk_status;
 };
 
 static int usbfs_snoop;
@@ -99,11 +103,15 @@ MODULE_PARM_DESC(usbfs_snoop, "true to log all usbfs traffic");
                         dev_info(dev , format , ## arg);        \
         } while (0)
 
-#define USB_DEVICE_DEV          MKDEV(USB_DEVICE_MAJOR, 0)
+enum snoop_when {
+        SUBMIT, COMPLETE
+};
 
+#define USB_DEVICE_DEV          MKDEV(USB_DEVICE_MAJOR, 0)
 
 #define MAX_USBFS_BUFFER_SIZE   16384
 
+
 static int connected(struct dev_state *ps)
 {
         return (!list_empty(&ps->list) &&
@@ -300,24 +308,79 @@ static struct async *async_getpending(struct dev_state *ps,
         return NULL;
 }
 
-static void snoop_urb(struct urb *urb, void __user *userurb)
+static void snoop_urb(struct usb_device *udev,
+                void __user *userurb, int pipe, unsigned length,
+                int timeout_or_status, enum snoop_when when)
 {
-        unsigned j;
-        unsigned char *data = urb->transfer_buffer;
+        static const char *types[] = {"isoc", "int", "ctrl", "bulk"};
+        static const char *dirs[] = {"out", "in"};
+        int ep;
+        const char *t, *d;
 
         if (!usbfs_snoop)
                 return;
 
-        dev_info(&urb->dev->dev, "direction=%s\n",
-                        usb_urb_dir_in(urb) ? "IN" : "OUT");
-        dev_info(&urb->dev->dev, "userurb=%p\n", userurb);
-        dev_info(&urb->dev->dev, "transfer_buffer_length=%u\n",
-                 urb->transfer_buffer_length);
-        dev_info(&urb->dev->dev, "actual_length=%u\n", urb->actual_length);
-        dev_info(&urb->dev->dev, "data: ");
-        for (j = 0; j < urb->transfer_buffer_length; ++j)
-                printk("%02x ", data[j]);
-        printk("\n");
+        ep = usb_pipeendpoint(pipe);
+        t = types[usb_pipetype(pipe)];
+        d = dirs[!!usb_pipein(pipe)];
+
+        if (userurb) {          /* Async */
+                if (when == SUBMIT)
+                        dev_info(&udev->dev, "userurb %p, ep%d %s-%s, "
+                                        "length %u\n",
+                                        userurb, ep, t, d, length);
+                else
+                        dev_info(&udev->dev, "userurb %p, ep%d %s-%s, "
+                                        "actual_length %u status %d\n",
+                                        userurb, ep, t, d, length,
+                                        timeout_or_status);
+        } else {
+                if (when == SUBMIT)
+                        dev_info(&udev->dev, "ep%d %s-%s, length %u, "
+                                        "timeout %d\n",
+                                        ep, t, d, length, timeout_or_status);
+                else
+                        dev_info(&udev->dev, "ep%d %s-%s, actual_length %u, "
+                                        "status %d\n",
+                                        ep, t, d, length, timeout_or_status);
+        }
+}
+
+#define AS_CONTINUATION 1
+#define AS_UNLINK       2
+
+static void cancel_bulk_urbs(struct dev_state *ps, unsigned bulk_addr)
+__releases(ps->lock)
+__acquires(ps->lock)
+{
+        struct async *as;
+
+        /* Mark all the pending URBs that match bulk_addr, up to but not
+         * including the first one without AS_CONTINUATION.  If such an
+         * URB is encountered then a new transfer has already started so
+         * the endpoint doesn't need to be disabled; otherwise it does.
+         */
+        list_for_each_entry(as, &ps->async_pending, asynclist) {
+                if (as->bulk_addr == bulk_addr) {
+                        if (as->bulk_status != AS_CONTINUATION)
+                                goto rescan;
+                        as->bulk_status = AS_UNLINK;
+                        as->bulk_addr = 0;
+                }
+        }
+        ps->disabled_bulk_eps |= (1 << bulk_addr);
+
+        /* Now carefully unlink all the marked pending URBs */
+ rescan:
+        list_for_each_entry(as, &ps->async_pending, asynclist) {
+                if (as->bulk_status == AS_UNLINK) {
+                        as->bulk_status = 0;            /* Only once */
+                        spin_unlock(&ps->lock);         /* Allow completions */
+                        usb_unlink_urb(as->urb);
+                        spin_lock(&ps->lock);
+                        goto rescan;
+                }
+        }
 }
 
 static void async_completed(struct urb *urb)
@@ -346,7 +409,11 @@ static void async_completed(struct urb *urb)
                 secid = as->secid;
         }
         snoop(&urb->dev->dev, "urb complete\n");
-        snoop_urb(urb, as->userurb);
+        snoop_urb(urb->dev, as->userurb, urb->pipe, urb->actual_length,
+                        as->status, COMPLETE);
+        if (as->status < 0 && as->bulk_addr && as->status != -ECONNRESET &&
+                        as->status != -ENOENT)
+                cancel_bulk_urbs(ps, as->bulk_addr);
         spin_unlock(&ps->lock);
 
         if (signr)
@@ -655,6 +722,7 @@ static int usbdev_release(struct inode *inode, struct file *file)
         struct async *as;
 
         usb_lock_device(dev);
+        usb_hub_release_all_ports(dev, ps);
 
         /* Protect against simultaneous open */
         mutex_lock(&usbfs_mutex);
@@ -688,7 +756,7 @@ static int proc_control(struct dev_state *ps, void __user *arg)
         unsigned int tmo;
         unsigned char *tbuf;
         unsigned wLength;
-        int i, j, ret;
+        int i, pipe, ret;
 
         if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
                 return -EFAULT;
@@ -708,24 +776,17 @@ static int proc_control(struct dev_state *ps, void __user *arg)
                         free_page((unsigned long)tbuf);
                         return -EINVAL;
                 }
-                snoop(&dev->dev, "control read: bRequest=%02x "
-                                "bRrequestType=%02x wValue=%04x "
-                                "wIndex=%04x wLength=%04x\n",
-                        ctrl.bRequest, ctrl.bRequestType, ctrl.wValue,
-                                ctrl.wIndex, ctrl.wLength);
+                pipe = usb_rcvctrlpipe(dev, 0);
+                snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT);
 
                 usb_unlock_device(dev);
-                i = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), ctrl.bRequest,
+                i = usb_control_msg(dev, pipe, ctrl.bRequest,
                                     ctrl.bRequestType, ctrl.wValue, ctrl.wIndex,
                                     tbuf, ctrl.wLength, tmo);
                 usb_lock_device(dev);
+                snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE);
+
                 if ((i > 0) && ctrl.wLength) {
-                        if (usbfs_snoop) {
-                                dev_info(&dev->dev, "control read: data ");
-                                for (j = 0; j < i; ++j)
-                                        printk("%02x ", (u8)(tbuf)[j]);
-                                printk("\n");
-                        }
                         if (copy_to_user(ctrl.data, tbuf, i)) {
                                 free_page((unsigned long)tbuf);
                                 return -EFAULT;
@@ -738,22 +799,15 @@ static int proc_control(struct dev_state *ps, void __user *arg)
                                 return -EFAULT;
                         }
                 }
-                snoop(&dev->dev, "control write: bRequest=%02x "
-                                "bRrequestType=%02x wValue=%04x "
-                                "wIndex=%04x wLength=%04x\n",
-                        ctrl.bRequest, ctrl.bRequestType, ctrl.wValue,
-                                ctrl.wIndex, ctrl.wLength);
-                if (usbfs_snoop) {
-                        dev_info(&dev->dev, "control write: data: ");
-                        for (j = 0; j < ctrl.wLength; ++j)
-                                printk("%02x ", (unsigned char)(tbuf)[j]);
-                        printk("\n");
-                }
+                pipe = usb_sndctrlpipe(dev, 0);
+                snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT);
+
                 usb_unlock_device(dev);
                 i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest,
                                     ctrl.bRequestType, ctrl.wValue, ctrl.wIndex,
                                     tbuf, ctrl.wLength, tmo);
                 usb_lock_device(dev);
+                snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE);
         }
         free_page((unsigned long)tbuf);
         if (i < 0 && i != -EPIPE) {
@@ -772,7 +826,7 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
         unsigned int tmo, len1, pipe;
         int len2;
         unsigned char *tbuf;
-        int i, j, ret;
+        int i, ret;
 
         if (copy_from_user(&bulk, arg, sizeof(bulk)))
                 return -EFAULT;
@@ -799,18 +853,14 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
                         kfree(tbuf);
                         return -EINVAL;
                 }
-                snoop(&dev->dev, "bulk read: len=0x%02x timeout=%04d\n",
-                        bulk.len, bulk.timeout);
+                snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT);
+
                 usb_unlock_device(dev);
                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
                 usb_lock_device(dev);
+                snoop_urb(dev, NULL, pipe, len2, i, COMPLETE);
+
                 if (!i && len2) {
-                        if (usbfs_snoop) {
-                                dev_info(&dev->dev, "bulk read: data ");
-                                for (j = 0; j < len2; ++j)
-                                        printk("%02x ", (u8)(tbuf)[j]);
-                                printk("\n");
-                        }
                         if (copy_to_user(bulk.data, tbuf, len2)) {
                                 kfree(tbuf);
                                 return -EFAULT;
@@ -823,17 +873,12 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
                                 return -EFAULT;
                         }
                 }
-                snoop(&dev->dev, "bulk write: len=0x%02x timeout=%04d\n",
-                        bulk.len, bulk.timeout);
-                if (usbfs_snoop) {
-                        dev_info(&dev->dev, "bulk write: data: ");
-                        for (j = 0; j < len1; ++j)
-                                printk("%02x ", (unsigned char)(tbuf)[j]);
-                        printk("\n");
-                }
+                snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT);
+
                 usb_unlock_device(dev);
                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
                 usb_lock_device(dev);
+                snoop_urb(dev, NULL, pipe, len2, i, COMPLETE);
         }
         kfree(tbuf);
         if (i < 0)
@@ -991,6 +1036,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
 
         if (uurb->flags & ~(USBDEVFS_URB_ISO_ASAP |
                                 USBDEVFS_URB_SHORT_NOT_OK |
+                                USBDEVFS_URB_BULK_CONTINUATION |
                                 USBDEVFS_URB_NO_FSBR |
                                 USBDEVFS_URB_ZERO_PACKET |
                                 USBDEVFS_URB_NO_INTERRUPT))
@@ -1051,13 +1097,6 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         is_in = 0;
                         uurb->endpoint &= ~USB_DIR_IN;
                 }
-                snoop(&ps->dev->dev, "control urb: bRequest=%02x "
-                        "bRrequestType=%02x wValue=%04x "
-                        "wIndex=%04x wLength=%04x\n",
-                        dr->bRequest, dr->bRequestType,
-                        __le16_to_cpup(&dr->wValue),
-                        __le16_to_cpup(&dr->wIndex),
-                        __le16_to_cpup(&dr->wLength));
                 break;
 
         case USBDEVFS_URB_TYPE_BULK:
@@ -1070,7 +1109,6 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 uurb->number_of_packets = 0;
                 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
                         return -EINVAL;
-                snoop(&ps->dev->dev, "bulk urb\n");
                 break;
 
         case USBDEVFS_URB_TYPE_ISO:
@@ -1097,12 +1135,12 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         }
                         totlen += isopkt[u].length;
                 }
-                if (totlen > 32768) {
+                /* 3072 * 64 microframes */
+                if (totlen > 196608) {
                         kfree(isopkt);
                         return -EINVAL;
                 }
                 uurb->buffer_length = totlen;
-                snoop(&ps->dev->dev, "iso urb\n");
                 break;
 
         case USBDEVFS_URB_TYPE_INTERRUPT:
@@ -1111,7 +1149,6 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         return -EINVAL;
                 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
                         return -EINVAL;
-                snoop(&ps->dev->dev, "interrupt urb\n");
                 break;
 
         default:
@@ -1198,11 +1235,46 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         return -EFAULT;
                 }
         }
-        snoop_urb(as->urb, as->userurb);
+        snoop_urb(ps->dev, as->userurb, as->urb->pipe,
+                        as->urb->transfer_buffer_length, 0, SUBMIT);
         async_newpending(as);
-        if ((ret = usb_submit_urb(as->urb, GFP_KERNEL))) {
+
+        if (usb_endpoint_xfer_bulk(&ep->desc)) {
+                spin_lock_irq(&ps->lock);
+
+                /* Not exactly the endpoint address; the direction bit is
+                 * shifted to the 0x10 position so that the value will be
+                 * between 0 and 31.
+                 */
+                as->bulk_addr = usb_endpoint_num(&ep->desc) |
+                        ((ep->desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK)
+                                >> 3);
+
+                /* If this bulk URB is the start of a new transfer, re-enable
+                 * the endpoint.  Otherwise mark it as a continuation URB.
+                 */
+                if (uurb->flags & USBDEVFS_URB_BULK_CONTINUATION)
+                        as->bulk_status = AS_CONTINUATION;
+                else
+                        ps->disabled_bulk_eps &= ~(1 << as->bulk_addr);
+
+                /* Don't accept continuation URBs if the endpoint is
+                 * disabled because of an earlier error.
+                 */
+                if (ps->disabled_bulk_eps & (1 << as->bulk_addr))
+                        ret = -EREMOTEIO;
+                else
+                        ret = usb_submit_urb(as->urb, GFP_ATOMIC);
+                spin_unlock_irq(&ps->lock);
+        } else {
+                ret = usb_submit_urb(as->urb, GFP_KERNEL);
+        }
+
+        if (ret) {
                 dev_printk(KERN_DEBUG, &ps->dev->dev,
                            "usbfs: usb_submit_urb returned %d\n", ret);
+                snoop_urb(ps->dev, as->userurb, as->urb->pipe,
+                                0, ret, COMPLETE);
                 async_removepending(as);
                 free_async(as);
                 return ret;
@@ -1548,6 +1620,29 @@ static int proc_ioctl_compat(struct dev_state *ps, compat_uptr_t arg)
 }
 #endif
 
+static int proc_claim_port(struct dev_state *ps, void __user *arg)
+{
+        unsigned portnum;
+        int rc;
+
+        if (get_user(portnum, (unsigned __user *) arg))
+                return -EFAULT;
+        rc = usb_hub_claim_port(ps->dev, portnum, ps);
+        if (rc == 0)
+                snoop(&ps->dev->dev, "port %d claimed by process %d: %s\n",
+                        portnum, task_pid_nr(current), current->comm);
+        return rc;
+}
+
+static int proc_release_port(struct dev_state *ps, void __user *arg)
+{
+        unsigned portnum;
+
+        if (get_user(portnum, (unsigned __user *) arg))
+                return -EFAULT;
+        return usb_hub_release_port(ps->dev, portnum, ps);
+}
+
 /*
  * NOTE:  All requests here that have interface numbers as parameters
  * are assuming that somehow the configuration has been prevented from
@@ -1645,7 +1740,7 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
                 break;
 
         case USBDEVFS_REAPURBNDELAY32:
-                snoop(&dev->dev, "%s: REAPURBDELAY32\n", __func__);
+                snoop(&dev->dev, "%s: REAPURBNDELAY32\n", __func__);
                 ret = proc_reapurbnonblock_compat(ps, p);
                 break;
 
@@ -1666,7 +1761,7 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
                 break;
 
         case USBDEVFS_REAPURBNDELAY:
-                snoop(&dev->dev, "%s: REAPURBDELAY\n", __func__);
+                snoop(&dev->dev, "%s: REAPURBNDELAY\n", __func__);
                 ret = proc_reapurbnonblock(ps, p);
                 break;
 
@@ -1689,6 +1784,16 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
                 snoop(&dev->dev, "%s: IOCTL\n", __func__);
                 ret = proc_ioctl_default(ps, p);
                 break;
+
+        case USBDEVFS_CLAIM_PORT:
+                snoop(&dev->dev, "%s: CLAIM_PORT\n", __func__);
+                ret = proc_claim_port(ps, p);
+                break;
+
+        case USBDEVFS_RELEASE_PORT:
+                snoop(&dev->dev, "%s: RELEASE_PORT\n", __func__);
+                ret = proc_release_port(ps, p);
+                break;
         }
         usb_unlock_device(dev);
         if (ret >= 0)
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 69e5773abfce..4f864472c5c4 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -207,6 +207,9 @@ static int usb_probe_interface(struct device *dev)
 
         intf->needs_binding = 0;
 
+        if (usb_device_is_owned(udev))
+                return -ENODEV;
+
         if (udev->authorized == 0) {
                 dev_err(&intf->dev, "Device is not authorized for usage\n");
                 return -ENODEV;
@@ -232,28 +235,35 @@ static int usb_probe_interface(struct device *dev)
                 /* The interface should always appear to be in use
                  * unless the driver suports autosuspend.
                  */
-                intf->pm_usage_cnt = !(driver->supports_autosuspend);
+                atomic_set(&intf->pm_usage_cnt, !driver->supports_autosuspend);
 
                 /* Carry out a deferred switch to altsetting 0 */
                 if (intf->needs_altsetting0) {
-                        usb_set_interface(udev, intf->altsetting[0].
+                        error = usb_set_interface(udev, intf->altsetting[0].
                                         desc.bInterfaceNumber, 0);
+                        if (error < 0)
+                                goto err;
+
                         intf->needs_altsetting0 = 0;
                 }
 
                 error = driver->probe(intf, id);
-                if (error) {
-                        mark_quiesced(intf);
-                        intf->needs_remote_wakeup = 0;
-                        intf->condition = USB_INTERFACE_UNBOUND;
-                        usb_cancel_queued_reset(intf);
-                } else
-                        intf->condition = USB_INTERFACE_BOUND;
+                if (error)
+                        goto err;
 
+                intf->condition = USB_INTERFACE_BOUND;
                 usb_autosuspend_device(udev);
         }
 
         return error;
+
+err:
+        mark_quiesced(intf);
+        intf->needs_remote_wakeup = 0;
+        intf->condition = USB_INTERFACE_UNBOUND;
+        usb_cancel_queued_reset(intf);
+        usb_autosuspend_device(udev);
+        return error;
 }
 
 /* called from driver core with dev locked */
@@ -262,7 +272,7 @@ static int usb_unbind_interface(struct device *dev)
         struct usb_driver *driver = to_usb_driver(dev->driver);
         struct usb_interface *intf = to_usb_interface(dev);
         struct usb_device *udev;
-        int error;
+        int error, r;
 
         intf->condition = USB_INTERFACE_UNBINDING;
 
@@ -290,11 +300,14 @@ static int usb_unbind_interface(struct device *dev)
                  * Just re-enable it without affecting the endpoint toggles.
                  */
                 usb_enable_interface(udev, intf, false);
-        } else if (!error && intf->dev.power.status == DPM_ON)
-                usb_set_interface(udev, intf->altsetting[0].
+        } else if (!error && intf->dev.power.status == DPM_ON) {
+                r = usb_set_interface(udev, intf->altsetting[0].
                                 desc.bInterfaceNumber, 0);
-        else
+                if (r < 0)
+                        intf->needs_altsetting0 = 1;
+        } else {
                 intf->needs_altsetting0 = 1;
+        }
         usb_set_intfdata(intf, NULL);
 
         intf->condition = USB_INTERFACE_UNBOUND;
@@ -344,7 +357,7 @@ int usb_driver_claim_interface(struct usb_driver *driver,
         usb_pm_lock(udev);
         iface->condition = USB_INTERFACE_BOUND;
         mark_active(iface);
-        iface->pm_usage_cnt = !(driver->supports_autosuspend);
+        atomic_set(&iface->pm_usage_cnt, !driver->supports_autosuspend);
         usb_pm_unlock(udev);
 
         /* if interface was already added, bind now; else let
@@ -1065,7 +1078,7 @@ static int autosuspend_check(struct usb_device *udev, int reschedule)
                         intf = udev->actconfig->interface[i];
                         if (!is_active(intf))
                                 continue;
-                        if (intf->pm_usage_cnt > 0)
+                        if (atomic_read(&intf->pm_usage_cnt) > 0)
                                 return -EBUSY;
                         if (intf->needs_remote_wakeup &&
                                         !udev->do_remote_wakeup) {
@@ -1461,17 +1474,19 @@ static int usb_autopm_do_interface(struct usb_interface *intf,
                 status = -ENODEV;
         else {
                 udev->auto_pm = 1;
-                intf->pm_usage_cnt += inc_usage_cnt;
+                atomic_add(inc_usage_cnt, &intf->pm_usage_cnt);
                 udev->last_busy = jiffies;
-                if (inc_usage_cnt >= 0 && intf->pm_usage_cnt > 0) {
+                if (inc_usage_cnt >= 0 &&
+                                atomic_read(&intf->pm_usage_cnt) > 0) {
                         if (udev->state == USB_STATE_SUSPENDED)
                                 status = usb_resume_both(udev,
                                                 PMSG_AUTO_RESUME);
                         if (status != 0)
-                                intf->pm_usage_cnt -= inc_usage_cnt;
+                                atomic_sub(inc_usage_cnt, &intf->pm_usage_cnt);
                         else
                                 udev->last_busy = jiffies;
-                } else if (inc_usage_cnt <= 0 && intf->pm_usage_cnt <= 0) {
+                } else if (inc_usage_cnt <= 0 &&
+                                atomic_read(&intf->pm_usage_cnt) <= 0) {
                         status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
                 }
         }
@@ -1516,7 +1531,7 @@ void usb_autopm_put_interface(struct usb_interface *intf)
 
         status = usb_autopm_do_interface(intf, -1);
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 
@@ -1544,10 +1559,10 @@ void usb_autopm_put_interface_async(struct usb_interface *intf)
                 status = -ENODEV;
         } else {
                 udev->last_busy = jiffies;
-                --intf->pm_usage_cnt;
+                atomic_dec(&intf->pm_usage_cnt);
                 if (udev->autosuspend_disabled || udev->autosuspend_delay < 0)
                         status = -EPERM;
-                else if (intf->pm_usage_cnt <= 0 &&
+                else if (atomic_read(&intf->pm_usage_cnt) <= 0 &&
                                 !timer_pending(&udev->autosuspend.timer)) {
                         queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
                                         round_jiffies_up_relative(
@@ -1555,7 +1570,7 @@ void usb_autopm_put_interface_async(struct usb_interface *intf)
                 }
         }
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
 
@@ -1599,7 +1614,7 @@ int usb_autopm_get_interface(struct usb_interface *intf)
 
         status = usb_autopm_do_interface(intf, 1);
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
         return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
@@ -1627,10 +1642,14 @@ int usb_autopm_get_interface_async(struct usb_interface *intf)
                 status = -ENODEV;
         else if (udev->autoresume_disabled)
                 status = -EPERM;
-        else if (++intf->pm_usage_cnt > 0 && udev->state == USB_STATE_SUSPENDED)
-                queue_work(ksuspend_usb_wq, &udev->autoresume);
+        else {
+                atomic_inc(&intf->pm_usage_cnt);
+                if (atomic_read(&intf->pm_usage_cnt) > 0 &&
+                                udev->state == USB_STATE_SUSPENDED)
+                        queue_work(ksuspend_usb_wq, &udev->autoresume);
+        }
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
         return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
@@ -1652,7 +1671,7 @@ int usb_autopm_set_interface(struct usb_interface *intf)
 
         status = usb_autopm_do_interface(intf, 0);
         dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, intf->pm_usage_cnt);
+                        __func__, status, atomic_read(&intf->pm_usage_cnt));
         return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
diff --git a/drivers/usb/core/generic.c b/drivers/usb/core/generic.c
index 30ecac3af15a..05e6d313961e 100644
--- a/drivers/usb/core/generic.c
+++ b/drivers/usb/core/generic.c
@@ -158,7 +158,9 @@ static int generic_probe(struct usb_device *udev)
         /* Choose and set the configuration.  This registers the interfaces
          * with the driver core and lets interface drivers bind to them.
          */
-        if (udev->authorized == 0)
+        if (usb_device_is_owned(udev))
+                ;               /* Don't configure if the device is owned */
+        else if (udev->authorized == 0)
                 dev_err(&udev->dev, "Device is not authorized for usage\n");
         else {
                 c = usb_choose_configuration(udev);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 95ccfa0b9fc5..34de475f016e 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -337,72 +337,89 @@ static const u8 ss_rh_config_descriptor[] = {
 
 /*-------------------------------------------------------------------------*/
 
-/*
- * helper routine for returning string descriptors in UTF-16LE
- * input can actually be ISO-8859-1; ASCII is its 7-bit subset
+/**
+ * ascii2desc() - Helper routine for producing UTF-16LE string descriptors
+ * @s: Null-terminated ASCII (actually ISO-8859-1) string
+ * @buf: Buffer for USB string descriptor (header + UTF-16LE)
+ * @len: Length (in bytes; may be odd) of descriptor buffer.
+ *
+ * The return value is the number of bytes filled in: 2 + 2*strlen(s) or
+ * buflen, whichever is less.
+ *
+ * USB String descriptors can contain at most 126 characters; input
+ * strings longer than that are truncated.
  */
-static unsigned ascii2utf(char *s, u8 *utf, int utfmax)
+static unsigned
+ascii2desc(char const *s, u8 *buf, unsigned len)
 {
-        unsigned retval;
+        unsigned n, t = 2 + 2*strlen(s);
 
-        for (retval = 0; *s && utfmax > 1; utfmax -= 2, retval += 2) {
-                *utf++ = *s++;
-                *utf++ = 0;
-        }
-        if (utfmax > 0) {
-                *utf = *s;
-                ++retval;
+        if (t > 254)
+                t = 254;        /* Longest possible UTF string descriptor */
+        if (len > t)
+                len = t;
+
+        t += USB_DT_STRING << 8;        /* Now t is first 16 bits to store */
+
+        n = len;
+        while (n--) {
+                *buf++ = t;
+                if (!n--)
+                        break;
+                *buf++ = t >> 8;
+                t = (unsigned char)*s++;
         }
-        return retval;
+        return len;
 }
 
-/*
- * rh_string - provides manufacturer, product and serial strings for root hub
- * @id: the string ID number (1: serial number, 2: product, 3: vendor)
+/**
+ * rh_string() - provides string descriptors for root hub
+ * @id: the string ID number (0: langids, 1: serial #, 2: product, 3: vendor)
  * @hcd: the host controller for this root hub
- * @data: return packet in UTF-16 LE
- * @len: length of the return packet
+ * @data: buffer for output packet
+ * @len: length of the provided buffer
  *
  * Produces either a manufacturer, product or serial number string for the
  * virtual root hub device.
+ * Returns the number of bytes filled in: the length of the descriptor or
+ * of the provided buffer, whichever is less.
  */
-static unsigned rh_string(int id, struct usb_hcd *hcd, u8 *data, unsigned len)
+static unsigned
+rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len)
 {
-        char buf [100];
+        char buf[100];
+        char const *s;
+        static char const langids[4] = {4, USB_DT_STRING, 0x09, 0x04};
 
         // language ids
-        if (id == 0) {
-                buf[0] = 4;    buf[1] = 3;      /* 4 bytes string data */
-                buf[2] = 0x09; buf[3] = 0x04;   /* MSFT-speak for "en-us" */
-                len = min_t(unsigned, len, 4);
-                memcpy (data, buf, len);
+        switch (id) {
+        case 0:
+                /* Array of LANGID codes (0x0409 is MSFT-speak for "en-us") */
+                /* See http://www.usb.org/developers/docs/USB_LANGIDs.pdf */
+                if (len > 4)
+                        len = 4;
+                memcpy(data, langids, len);
                 return len;
-
-        // serial number
-        } else if (id == 1) {
-                strlcpy (buf, hcd->self.bus_name, sizeof buf);
-
-        // product description
-        } else if (id == 2) {
-                strlcpy (buf, hcd->product_desc, sizeof buf);
-
-        // id 3 == vendor description
-        } else if (id == 3) {
+        case 1:
+                /* Serial number */
+                s = hcd->self.bus_name;
+                break;
+        case 2:
+                /* Product name */
+                s = hcd->product_desc;
+                break;
+        case 3:
+                /* Manufacturer */
                 snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname,
                         init_utsname()->release, hcd->driver->description);
-        }
-
-        switch (len) {          /* All cases fall through */
+                s = buf;
+                break;
         default:
-                len = 2 + ascii2utf (buf, data + 2, len - 2);
-        case 2:
-                data [1] = 3;   /* type == string */
-        case 1:
-                data [0] = 2 * (strlen (buf) + 1);
-        case 0:
-                ;               /* Compiler wants a statement here */
+                /* Can't happen; caller guarantees it */
+                return 0;
         }
-        return len;
+
+        return ascii2desc(s, data, len);
 }
 
 
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index ec5c67ea07b7..79782a1c43f6 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -267,6 +267,11 @@ struct hc_driver {
         void    (*reset_bandwidth)(struct usb_hcd *, struct usb_device *);
                 /* Returns the hardware-chosen device address */
         int     (*address_device)(struct usb_hcd *, struct usb_device *udev);
+                /* Notifies the HCD after a hub descriptor is fetched.
+                 * Will block.
+                 */
+        int     (*update_hub_device)(struct usb_hcd *, struct usb_device *hdev,
+                        struct usb_tt *tt, gfp_t mem_flags);
 };
 
 extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb);
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 71f86c60d83c..5ce839137ad6 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -78,6 +78,7 @@ struct usb_hub {
         u8                      indicator[USB_MAXCHILDREN];
         struct delayed_work     leds;
         struct delayed_work     init_work;
+        void                    **port_owners;
 };
 
 
@@ -162,8 +163,10 @@ static inline char *portspeed(int portstatus)
 }
 
 /* Note that hdev or one of its children must be locked! */
-static inline struct usb_hub *hdev_to_hub(struct usb_device *hdev)
+static struct usb_hub *hdev_to_hub(struct usb_device *hdev)
 {
+        if (!hdev || !hdev->actconfig)
+                return NULL;
         return usb_get_intfdata(hdev->actconfig->interface[0]);
 }
 
@@ -372,7 +375,7 @@ static void kick_khubd(struct usb_hub *hub)
         unsigned long   flags;
 
         /* Suppress autosuspend until khubd runs */
-        to_usb_interface(hub->intfdev)->pm_usage_cnt = 1;
+        atomic_set(&to_usb_interface(hub->intfdev)->pm_usage_cnt, 1);
 
         spin_lock_irqsave(&hub_event_lock, flags);
         if (!hub->disconnected && list_empty(&hub->event_list)) {
@@ -384,8 +387,10 @@ static void kick_khubd(struct usb_hub *hub)
 
 void usb_kick_khubd(struct usb_device *hdev)
 {
-        /* FIXME: What if hdev isn't bound to the hub driver? */
-        kick_khubd(hdev_to_hub(hdev));
+        struct usb_hub *hub = hdev_to_hub(hdev);
+
+        if (hub)
+                kick_khubd(hub);
 }
 
 
@@ -677,7 +682,8 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                         msecs_to_jiffies(delay));
 
                         /* Suppress autosuspend until init is done */
-                        to_usb_interface(hub->intfdev)->pm_usage_cnt = 1;
+                        atomic_set(&to_usb_interface(hub->intfdev)->
+                                        pm_usage_cnt, 1);
                         return;         /* Continues at init2: below */
                 } else {
                         hub_power_on(hub, true);
@@ -854,25 +860,24 @@ static int hub_post_reset(struct usb_interface *intf)
 static int hub_configure(struct usb_hub *hub,
         struct usb_endpoint_descriptor *endpoint)
 {
+        struct usb_hcd *hcd;
         struct usb_device *hdev = hub->hdev;
         struct device *hub_dev = hub->intfdev;
         u16 hubstatus, hubchange;
         u16 wHubCharacteristics;
         unsigned int pipe;
         int maxp, ret;
-        char *message;
+        char *message = "out of memory";
 
         hub->buffer = usb_buffer_alloc(hdev, sizeof(*hub->buffer), GFP_KERNEL,
                         &hub->buffer_dma);
         if (!hub->buffer) {
-                message = "can't allocate hub irq buffer";
                 ret = -ENOMEM;
                 goto fail;
         }
 
         hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
         if (!hub->status) {
-                message = "can't kmalloc hub status buffer";
                 ret = -ENOMEM;
                 goto fail;
         }
@@ -880,7 +885,6 @@ static int hub_configure(struct usb_hub *hub,
 
         hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
         if (!hub->descriptor) {
-                message = "can't kmalloc hub descriptor";
                 ret = -ENOMEM;
                 goto fail;
         }
@@ -904,6 +908,12 @@ static int hub_configure(struct usb_hub *hub,
         dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
                 (hdev->maxchild == 1) ? "" : "s");
 
+        hub->port_owners = kzalloc(hdev->maxchild * sizeof(void *), GFP_KERNEL);
+        if (!hub->port_owners) {
+                ret = -ENOMEM;
+                goto fail;
+        }
+
         wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 
         if (wHubCharacteristics & HUB_CHAR_COMPOUND) {
@@ -1052,6 +1062,19 @@ static int hub_configure(struct usb_hub *hub,
                 dev_dbg(hub_dev, "%umA bus power budget for each child\n",
                                 hub->mA_per_port);
 
+        /* Update the HCD's internal representation of this hub before khubd
+         * starts getting port status changes for devices under the hub.
+         */
+        hcd = bus_to_hcd(hdev->bus);
+        if (hcd->driver->update_hub_device) {
+                ret = hcd->driver->update_hub_device(hcd, hdev,
+                                &hub->tt, GFP_KERNEL);
+                if (ret < 0) {
+                        message = "can't update HCD hub info";
+                        goto fail;
+                }
+        }
+
         ret = hub_hub_status(hub, &hubstatus, &hubchange);
         if (ret < 0) {
                 message = "can't get hub status";
@@ -1082,7 +1105,6 @@ static int hub_configure(struct usb_hub *hub,
 
         hub->urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!hub->urb) {
-                message = "couldn't allocate interrupt urb";
                 ret = -ENOMEM;
                 goto fail;
         }
@@ -1131,11 +1153,13 @@ static void hub_disconnect(struct usb_interface *intf)
         hub_quiesce(hub, HUB_DISCONNECT);
 
         usb_set_intfdata (intf, NULL);
+        hub->hdev->maxchild = 0;
 
         if (hub->hdev->speed == USB_SPEED_HIGH)
                 highspeed_hubs--;
 
         usb_free_urb(hub->urb);
+        kfree(hub->port_owners);
         kfree(hub->descriptor);
         kfree(hub->status);
         usb_buffer_free(hub->hdev, sizeof(*hub->buffer), hub->buffer,
@@ -1250,6 +1274,79 @@ hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
         }
 }
 
+/*
+ * Allow user programs to claim ports on a hub.  When a device is attached
+ * to one of these "claimed" ports, the program will "own" the device.
+ */
+static int find_port_owner(struct usb_device *hdev, unsigned port1,
+                void ***ppowner)
+{
+        if (hdev->state == USB_STATE_NOTATTACHED)
+                return -ENODEV;
+        if (port1 == 0 || port1 > hdev->maxchild)
+                return -EINVAL;
+
+        /* This assumes that devices not managed by the hub driver
+         * will always have maxchild equal to 0.
+         */
+        *ppowner = &(hdev_to_hub(hdev)->port_owners[port1 - 1]);
+        return 0;
+}
+
+/* In the following three functions, the caller must hold hdev's lock */
+int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, void *owner)
+{
+        int rc;
+        void **powner;
+
+        rc = find_port_owner(hdev, port1, &powner);
+        if (rc)
+                return rc;
+        if (*powner)
+                return -EBUSY;
+        *powner = owner;
+        return rc;
+}
+
+int usb_hub_release_port(struct usb_device *hdev, unsigned port1, void *owner)
+{
+        int rc;
+        void **powner;
+
+        rc = find_port_owner(hdev, port1, &powner);
+        if (rc)
+                return rc;
+        if (*powner != owner)
+                return -ENOENT;
+        *powner = NULL;
+        return rc;
+}
+
+void usb_hub_release_all_ports(struct usb_device *hdev, void *owner)
+{
+        int n;
+        void **powner;
+
+        n = find_port_owner(hdev, 1, &powner);
+        if (n == 0) {
+                for (; n < hdev->maxchild; (++n, ++powner)) {
+                        if (*powner == owner)
+                                *powner = NULL;
+                }
+        }
+}
+
+/* The caller must hold udev's lock */
+bool usb_device_is_owned(struct usb_device *udev)
+{
+        struct usb_hub *hub;
+
+        if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
+                return false;
+        hub = hdev_to_hub(udev->parent);
+        return !!hub->port_owners[udev->portnum - 1];
+}
+
 
 static void recursively_mark_NOTATTACHED(struct usb_device *udev)
 {
@@ -2849,14 +2946,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                         /* For a suspended device, treat this as a
                          * remote wakeup event.
                          */
-                        if (udev->do_remote_wakeup)
-                                status = remote_wakeup(udev);
-
-                        /* Otherwise leave it be; devices can't tell the
-                         * difference between suspended and disabled.
-                         */
-                        else
-                                status = 0;
+                        status = remote_wakeup(udev);
 #endif
 
                 } else {
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 9720e699f472..da718e84d58d 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -459,35 +459,23 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
                         io->urbs[i]->context = io;
 
                         /*
-                         * Some systems need to revert to PIO when DMA is
-                         * temporarily unavailable.  For their sakes, both
-                         * transfer_buffer and transfer_dma are set when
-                         * possible.  However this can only work on systems
-                         * without:
+                         * Some systems need to revert to PIO when DMA is temporarily
+                         * unavailable.  For their sakes, both transfer_buffer and
+                         * transfer_dma are set when possible.
                          *
-                         *  - HIGHMEM, since DMA buffers located in high memory
-                         *    are not directly addressable by the CPU for PIO;
-                         *
-                         *  - IOMMU, since dma_map_sg() is allowed to use an
-                         *    IOMMU to make virtually discontiguous buffers be
-                         *    "dma-contiguous" so that PIO and DMA need diferent
-                         *    numbers of URBs.
-                         *
-                         * So when HIGHMEM or IOMMU are in use, transfer_buffer
-                         * is NULL to prevent stale pointers and to help spot
-                         * bugs.
+                         * Note that if IOMMU coalescing occurred, we cannot
+                         * trust sg_page anymore, so check if S/G list shrunk.
                          */
+                        if (io->nents == io->entries && !PageHighMem(sg_page(sg)))
+                                io->urbs[i]->transfer_buffer = sg_virt(sg);
+                        else
+                                io->urbs[i]->transfer_buffer = NULL;
+
                         if (dma) {
                                 io->urbs[i]->transfer_dma = sg_dma_address(sg);
                                 len = sg_dma_len(sg);
-#if defined(CONFIG_HIGHMEM) || defined(CONFIG_GART_IOMMU)
-                                io->urbs[i]->transfer_buffer = NULL;
-#else
-                                io->urbs[i]->transfer_buffer = sg_virt(sg);
-#endif
                         } else {
                                 /* hc may use _only_ transfer_buffer */
-                                io->urbs[i]->transfer_buffer = sg_virt(sg);
                                 len = sg->length;
                         }
 
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 43ee943d757a..b1b85abb9a2d 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -413,8 +413,13 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
                 } else {
                         snprintf(dev->devpath, sizeof dev->devpath,
                                 "%s.%d", parent->devpath, port1);
-                        dev->route = parent->route +
-                                (port1 << ((parent->level - 1)*4));
+                        /* Route string assumes hubs have less than 16 ports */
+                        if (port1 < 15)
+                                dev->route = parent->route +
+                                        (port1 << ((parent->level - 1)*4));
+                        else
+                                dev->route = parent->route +
+                                        (15 << ((parent->level - 1)*4));
                 }
 
                 dev->dev.parent = &parent->dev;
@@ -914,11 +919,11 @@ int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
                         || !(bus = dev->bus)
                         || !(controller = bus->controller)
                         || !controller->dma_mask)
-                return -1;
+                return -EINVAL;
 
         /* FIXME generic api broken like pci, can't report errors */
         return dma_map_sg(controller, sg, nents,
-                        is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
+                        is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM;
 }
 EXPORT_SYMBOL_GPL(usb_buffer_map_sg);
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index c0e0ae2bb8e7..9a8b15e6377a 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -37,6 +37,13 @@ extern int usb_match_device(struct usb_device *dev,
 extern void usb_forced_unbind_intf(struct usb_interface *intf);
 extern void usb_rebind_intf(struct usb_interface *intf);
 
+extern int usb_hub_claim_port(struct usb_device *hdev, unsigned port,
+                void *owner);
+extern int usb_hub_release_port(struct usb_device *hdev, unsigned port,
+                void *owner);
+extern void usb_hub_release_all_ports(struct usb_device *hdev, void *owner);
+extern bool usb_device_is_owned(struct usb_device *udev);
+
 extern int  usb_hub_init(void);
 extern void usb_hub_cleanup(void);
 extern int usb_major_init(void);
diff --git a/drivers/usb/early/Makefile b/drivers/usb/early/Makefile
new file mode 100644
index 000000000000..dfedee8c45b6
--- /dev/null
+++ b/drivers/usb/early/Makefile
@@ -0,0 +1,5 @@
+#
+# Makefile for early USB devices
+#
+
+obj-$(CONFIG_EARLY_PRINTK_DBGP)        += ehci-dbgp.o
diff --git a/drivers/usb/early/ehci-dbgp.c b/drivers/usb/early/ehci-dbgp.c
new file mode 100644
index 000000000000..1206a26ef893
--- /dev/null
+++ b/drivers/usb/early/ehci-dbgp.c
@@ -0,0 +1,996 @@
+/*
+ * Standalone EHCI usb debug driver
+ *
+ * Originally written by:
+ *  Eric W. Biederman" <ebiederm@xmission.com> and
+ *  Yinghai Lu <yhlu.kernel@gmail.com>
+ *
+ * Changes for early/late printk and HW errata:
+ *  Jason Wessel <jason.wessel@windriver.com>
+ *  Copyright (C) 2009 Wind River Systems, Inc.
+ *
+ */
+
+#include <linux/console.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/pci_regs.h>
+#include <linux/pci_ids.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/ehci_def.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+#include <asm/pci-direct.h>
+#include <asm/fixmap.h>
+
+/* The code here is intended to talk directly to the EHCI debug port
+ * and does not require that you have any kind of USB host controller
+ * drivers or USB device drivers compiled into the kernel.
+ *
+ * If you make a change to anything in here, the following test cases
+ * need to pass where a USB debug device works in the following
+ * configurations.
+ *
+ * 1. boot args:  earlyprintk=dbgp
+ *     o kernel compiled with # CONFIG_USB_EHCI_HCD is not set
+ *     o kernel compiled with CONFIG_USB_EHCI_HCD=y
+ * 2. boot args: earlyprintk=dbgp,keep
+ *     o kernel compiled with # CONFIG_USB_EHCI_HCD is not set
+ *     o kernel compiled with CONFIG_USB_EHCI_HCD=y
+ * 3. boot args: earlyprintk=dbgp console=ttyUSB0
+ *     o kernel has CONFIG_USB_EHCI_HCD=y and
+ *       CONFIG_USB_SERIAL_DEBUG=y
+ * 4. boot args: earlyprintk=vga,dbgp
+ *     o kernel compiled with # CONFIG_USB_EHCI_HCD is not set
+ *     o kernel compiled with CONFIG_USB_EHCI_HCD=y
+ *
+ * For the 4th configuration you can turn on or off the DBGP_DEBUG
+ * such that you can debug the dbgp device's driver code.
+ */
+
+static int dbgp_phys_port = 1;
+
+static struct ehci_caps __iomem *ehci_caps;
+static struct ehci_regs __iomem *ehci_regs;
+static struct ehci_dbg_port __iomem *ehci_debug;
+static int dbgp_not_safe; /* Cannot use debug device during ehci reset */
+static unsigned int dbgp_endpoint_out;
+
+struct ehci_dev {
+        u32 bus;
+        u32 slot;
+        u32 func;
+};
+
+static struct ehci_dev ehci_dev;
+
+#define USB_DEBUG_DEVNUM 127
+
+#define DBGP_DATA_TOGGLE        0x8800
+
+#ifdef DBGP_DEBUG
+#define dbgp_printk printk
+static void dbgp_ehci_status(char *str)
+{
+        if (!ehci_debug)
+                return;
+        dbgp_printk("dbgp: %s\n", str);
+        dbgp_printk("  Debug control: %08x", readl(&ehci_debug->control));
+        dbgp_printk("  ehci cmd     : %08x", readl(&ehci_regs->command));
+        dbgp_printk("  ehci conf flg: %08x\n",
+                    readl(&ehci_regs->configured_flag));
+        dbgp_printk("  ehci status  : %08x", readl(&ehci_regs->status));
+        dbgp_printk("  ehci portsc  : %08x\n",
+                    readl(&ehci_regs->port_status[dbgp_phys_port - 1]));
+}
+#else
+static inline void dbgp_ehci_status(char *str) { }
+static inline void dbgp_printk(const char *fmt, ...) { }
+#endif
+
+static inline u32 dbgp_pid_update(u32 x, u32 tok)
+{
+        return ((x ^ DBGP_DATA_TOGGLE) & 0xffff00) | (tok & 0xff);
+}
+
+static inline u32 dbgp_len_update(u32 x, u32 len)
+{
+        return (x & ~0x0f) | (len & 0x0f);
+}
+
+/*
+ * USB Packet IDs (PIDs)
+ */
+
+/* token */
+#define USB_PID_OUT             0xe1
+#define USB_PID_IN              0x69
+#define USB_PID_SOF             0xa5
+#define USB_PID_SETUP           0x2d
+/* handshake */
+#define USB_PID_ACK             0xd2
+#define USB_PID_NAK             0x5a
+#define USB_PID_STALL           0x1e
+#define USB_PID_NYET            0x96
+/* data */
+#define USB_PID_DATA0           0xc3
+#define USB_PID_DATA1           0x4b
+#define USB_PID_DATA2           0x87
+#define USB_PID_MDATA           0x0f
+/* Special */
+#define USB_PID_PREAMBLE        0x3c
+#define USB_PID_ERR             0x3c
+#define USB_PID_SPLIT           0x78
+#define USB_PID_PING            0xb4
+#define USB_PID_UNDEF_0         0xf0
+
+#define USB_PID_DATA_TOGGLE     0x88
+#define DBGP_CLAIM (DBGP_OWNER | DBGP_ENABLED | DBGP_INUSE)
+
+#define PCI_CAP_ID_EHCI_DEBUG   0xa
+
+#define HUB_ROOT_RESET_TIME     50      /* times are in msec */
+#define HUB_SHORT_RESET_TIME    10
+#define HUB_LONG_RESET_TIME     200
+#define HUB_RESET_TIMEOUT       500
+
+#define DBGP_MAX_PACKET         8
+#define DBGP_TIMEOUT            (250 * 1000)
+
+static int dbgp_wait_until_complete(void)
+{
+        u32 ctrl;
+        int loop = DBGP_TIMEOUT;
+
+        do {
+                ctrl = readl(&ehci_debug->control);
+                /* Stop when the transaction is finished */
+                if (ctrl & DBGP_DONE)
+                        break;
+                udelay(1);
+        } while (--loop > 0);
+
+        if (!loop)
+                return -DBGP_TIMEOUT;
+
+        /*
+         * Now that we have observed the completed transaction,
+         * clear the done bit.
+         */
+        writel(ctrl | DBGP_DONE, &ehci_debug->control);
+        return (ctrl & DBGP_ERROR) ? -DBGP_ERRCODE(ctrl) : DBGP_LEN(ctrl);
+}
+
+static inline void dbgp_mdelay(int ms)
+{
+        int i;
+
+        while (ms--) {
+                for (i = 0; i < 1000; i++)
+                        outb(0x1, 0x80);
+        }
+}
+
+static void dbgp_breath(void)
+{
+        /* Sleep to give the debug port a chance to breathe */
+}
+
+static int dbgp_wait_until_done(unsigned ctrl)
+{
+        u32 pids, lpid;
+        int ret;
+        int loop = 3;
+
+retry:
+        writel(ctrl | DBGP_GO, &ehci_debug->control);
+        ret = dbgp_wait_until_complete();
+        pids = readl(&ehci_debug->pids);
+        lpid = DBGP_PID_GET(pids);
+
+        if (ret < 0) {
+                /* A -DBGP_TIMEOUT failure here means the device has
+                 * failed, perhaps because it was unplugged, in which
+                 * case we do not want to hang the system so the dbgp
+                 * will be marked as unsafe to use.  EHCI reset is the
+                 * only way to recover if you unplug the dbgp device.
+                 */
+                if (ret == -DBGP_TIMEOUT && !dbgp_not_safe)
+                        dbgp_not_safe = 1;
+                return ret;
+        }
+
+        /*
+         * If the port is getting full or it has dropped data
+         * start pacing ourselves, not necessary but it's friendly.
+         */
+        if ((lpid == USB_PID_NAK) || (lpid == USB_PID_NYET))
+                dbgp_breath();
+
+        /* If I get a NACK reissue the transmission */
+        if (lpid == USB_PID_NAK) {
+                if (--loop > 0)
+                        goto retry;
+        }
+
+        return ret;
+}
+
+static inline void dbgp_set_data(const void *buf, int size)
+{
+        const unsigned char *bytes = buf;
+        u32 lo, hi;
+        int i;
+
+        lo = hi = 0;
+        for (i = 0; i < 4 && i < size; i++)
+                lo |= bytes[i] << (8*i);
+        for (; i < 8 && i < size; i++)
+                hi |= bytes[i] << (8*(i - 4));
+        writel(lo, &ehci_debug->data03);
+        writel(hi, &ehci_debug->data47);
+}
+
+static inline void dbgp_get_data(void *buf, int size)
+{
+        unsigned char *bytes = buf;
+        u32 lo, hi;
+        int i;
+
+        lo = readl(&ehci_debug->data03);
+        hi = readl(&ehci_debug->data47);
+        for (i = 0; i < 4 && i < size; i++)
+                bytes[i] = (lo >> (8*i)) & 0xff;
+        for (; i < 8 && i < size; i++)
+                bytes[i] = (hi >> (8*(i - 4))) & 0xff;
+}
+
+static int dbgp_out(u32 addr, const char *bytes, int size)
+{
+        u32 pids, ctrl;
+
+        pids = readl(&ehci_debug->pids);
+        pids = dbgp_pid_update(pids, USB_PID_OUT);
+
+        ctrl = readl(&ehci_debug->control);
+        ctrl = dbgp_len_update(ctrl, size);
+        ctrl |= DBGP_OUT;
+        ctrl |= DBGP_GO;
+
+        dbgp_set_data(bytes, size);
+        writel(addr, &ehci_debug->address);
+        writel(pids, &ehci_debug->pids);
+        return dbgp_wait_until_done(ctrl);
+}
+
+static int dbgp_bulk_write(unsigned devnum, unsigned endpoint,
+                         const char *bytes, int size)
+{
+        int ret;
+        int loops = 5;
+        u32 addr;
+        if (size > DBGP_MAX_PACKET)
+                return -1;
+
+        addr = DBGP_EPADDR(devnum, endpoint);
+try_again:
+        if (loops--) {
+                ret = dbgp_out(addr, bytes, size);
+                if (ret == -DBGP_ERR_BAD) {
+                        int try_loops = 3;
+                        do {
+                                /* Emit a dummy packet to re-sync communication
+                                 * with the debug device */
+                                if (dbgp_out(addr, "12345678", 8) >= 0) {
+                                        udelay(2);
+                                        goto try_again;
+                                }
+                        } while (try_loops--);
+                }
+        }
+
+        return ret;
+}
+
+static int dbgp_bulk_read(unsigned devnum, unsigned endpoint, void *data,
+                                 int size)
+{
+        u32 pids, addr, ctrl;
+        int ret;
+
+        if (size > DBGP_MAX_PACKET)
+                return -1;
+
+        addr = DBGP_EPADDR(devnum, endpoint);
+
+        pids = readl(&ehci_debug->pids);
+        pids = dbgp_pid_update(pids, USB_PID_IN);
+
+        ctrl = readl(&ehci_debug->control);
+        ctrl = dbgp_len_update(ctrl, size);
+        ctrl &= ~DBGP_OUT;
+        ctrl |= DBGP_GO;
+
+        writel(addr, &ehci_debug->address);
+        writel(pids, &ehci_debug->pids);
+        ret = dbgp_wait_until_done(ctrl);
+        if (ret < 0)
+                return ret;
+
+        if (size > ret)
+                size = ret;
+        dbgp_get_data(data, size);
+        return ret;
+}
+
+static int dbgp_control_msg(unsigned devnum, int requesttype,
+        int request, int value, int index, void *data, int size)
+{
+        u32 pids, addr, ctrl;
+        struct usb_ctrlrequest req;
+        int read;
+        int ret;
+
+        read = (requesttype & USB_DIR_IN) != 0;
+        if (size > (read ? DBGP_MAX_PACKET:0))
+                return -1;
+
+        /* Compute the control message */
+        req.bRequestType = requesttype;
+        req.bRequest = request;
+        req.wValue = cpu_to_le16(value);
+        req.wIndex = cpu_to_le16(index);
+        req.wLength = cpu_to_le16(size);
+
+        pids = DBGP_PID_SET(USB_PID_DATA0, USB_PID_SETUP);
+        addr = DBGP_EPADDR(devnum, 0);
+
+        ctrl = readl(&ehci_debug->control);
+        ctrl = dbgp_len_update(ctrl, sizeof(req));
+        ctrl |= DBGP_OUT;
+        ctrl |= DBGP_GO;
+
+        /* Send the setup message */
+        dbgp_set_data(&req, sizeof(req));
+        writel(addr, &ehci_debug->address);
+        writel(pids, &ehci_debug->pids);
+        ret = dbgp_wait_until_done(ctrl);
+        if (ret < 0)
+                return ret;
+
+        /* Read the result */
+        return dbgp_bulk_read(devnum, 0, data, size);
+}
+
+
+/* Find a PCI capability */
+static u32 __init find_cap(u32 num, u32 slot, u32 func, int cap)
+{
+        u8 pos;
+        int bytes;
+
+        if (!(read_pci_config_16(num, slot, func, PCI_STATUS) &
+                PCI_STATUS_CAP_LIST))
+                return 0;
+
+        pos = read_pci_config_byte(num, slot, func, PCI_CAPABILITY_LIST);
+        for (bytes = 0; bytes < 48 && pos >= 0x40; bytes++) {
+                u8 id;
+
+                pos &= ~3;
+                id = read_pci_config_byte(num, slot, func, pos+PCI_CAP_LIST_ID);
+                if (id == 0xff)
+                        break;
+                if (id == cap)
+                        return pos;
+
+                pos = read_pci_config_byte(num, slot, func,
+                                                 pos+PCI_CAP_LIST_NEXT);
+        }
+        return 0;
+}
+
+static u32 __init __find_dbgp(u32 bus, u32 slot, u32 func)
+{
+        u32 class;
+
+        class = read_pci_config(bus, slot, func, PCI_CLASS_REVISION);
+        if ((class >> 8) != PCI_CLASS_SERIAL_USB_EHCI)
+                return 0;
+
+        return find_cap(bus, slot, func, PCI_CAP_ID_EHCI_DEBUG);
+}
+
+static u32 __init find_dbgp(int ehci_num, u32 *rbus, u32 *rslot, u32 *rfunc)
+{
+        u32 bus, slot, func;
+
+        for (bus = 0; bus < 256; bus++) {
+                for (slot = 0; slot < 32; slot++) {
+                        for (func = 0; func < 8; func++) {
+                                unsigned cap;
+
+                                cap = __find_dbgp(bus, slot, func);
+
+                                if (!cap)
+                                        continue;
+                                if (ehci_num-- != 0)
+                                        continue;
+                                *rbus = bus;
+                                *rslot = slot;
+                                *rfunc = func;
+                                return cap;
+                        }
+                }
+        }
+        return 0;
+}
+
+static int dbgp_ehci_startup(void)
+{
+        u32 ctrl, cmd, status;
+        int loop;
+
+        /* Claim ownership, but do not enable yet */
+        ctrl = readl(&ehci_debug->control);
+        ctrl |= DBGP_OWNER;
+        ctrl &= ~(DBGP_ENABLED | DBGP_INUSE);
+        writel(ctrl, &ehci_debug->control);
+        udelay(1);
+
+        dbgp_ehci_status("EHCI startup");
+        /* Start the ehci running */
+        cmd = readl(&ehci_regs->command);
+        cmd &= ~(CMD_LRESET | CMD_IAAD | CMD_PSE | CMD_ASE | CMD_RESET);
+        cmd |= CMD_RUN;
+        writel(cmd, &ehci_regs->command);
+
+        /* Ensure everything is routed to the EHCI */
+        writel(FLAG_CF, &ehci_regs->configured_flag);
+
+        /* Wait until the controller is no longer halted */
+        loop = 10;
+        do {
+                status = readl(&ehci_regs->status);
+                if (!(status & STS_HALT))
+                        break;
+                udelay(1);
+        } while (--loop > 0);
+
+        if (!loop) {
+                dbgp_printk("ehci can not be started\n");
+                return -ENODEV;
+        }
+        dbgp_printk("ehci started\n");
+        return 0;
+}
+
+static int dbgp_ehci_controller_reset(void)
+{
+        int loop = 250 * 1000;
+        u32 cmd;
+
+        /* Reset the EHCI controller */
+        cmd = readl(&ehci_regs->command);
+        cmd |= CMD_RESET;
+        writel(cmd, &ehci_regs->command);
+        do {
+                cmd = readl(&ehci_regs->command);
+        } while ((cmd & CMD_RESET) && (--loop > 0));
+
+        if (!loop) {
+                dbgp_printk("can not reset ehci\n");
+                return -1;
+        }
+        dbgp_ehci_status("ehci reset done");
+        return 0;
+}
+static int ehci_wait_for_port(int port);
+/* Return 0 on success
+ * Return -ENODEV for any general failure
+ * Return -EIO if wait for port fails
+ */
+int dbgp_external_startup(void)
+{
+        int devnum;
+        struct usb_debug_descriptor dbgp_desc;
+        int ret;
+        u32 ctrl, portsc, cmd;
+        int dbg_port = dbgp_phys_port;
+        int tries = 3;
+        int reset_port_tries = 1;
+        int try_hard_once = 1;
+
+try_port_reset_again:
+        ret = dbgp_ehci_startup();
+        if (ret)
+                return ret;
+
+        /* Wait for a device to show up in the debug port */
+        ret = ehci_wait_for_port(dbg_port);
+        if (ret < 0) {
+                portsc = readl(&ehci_regs->port_status[dbg_port - 1]);
+                if (!(portsc & PORT_CONNECT) && try_hard_once) {
+                        /* Last ditch effort to try to force enable
+                         * the debug device by using the packet test
+                         * ehci command to try and wake it up. */
+                        try_hard_once = 0;
+                        cmd = readl(&ehci_regs->command);
+                        cmd &= ~CMD_RUN;
+                        writel(cmd, &ehci_regs->command);
+                        portsc = readl(&ehci_regs->port_status[dbg_port - 1]);
+                        portsc |= PORT_TEST_PKT;
+                        writel(portsc, &ehci_regs->port_status[dbg_port - 1]);
+                        dbgp_ehci_status("Trying to force debug port online");
+                        mdelay(50);
+                        dbgp_ehci_controller_reset();
+                        goto try_port_reset_again;
+                } else if (reset_port_tries--) {
+                        goto try_port_reset_again;
+                }
+                dbgp_printk("No device found in debug port\n");
+                return -EIO;
+        }
+        dbgp_ehci_status("wait for port done");
+
+        /* Enable the debug port */
+        ctrl = readl(&ehci_debug->control);
+        ctrl |= DBGP_CLAIM;
+        writel(ctrl, &ehci_debug->control);
+        ctrl = readl(&ehci_debug->control);
+        if ((ctrl & DBGP_CLAIM) != DBGP_CLAIM) {
+                dbgp_printk("No device in debug port\n");
+                writel(ctrl & ~DBGP_CLAIM, &ehci_debug->control);
+                return -ENODEV;
+        }
+        dbgp_ehci_status("debug ported enabled");
+
+        /* Completely transfer the debug device to the debug controller */
+        portsc = readl(&ehci_regs->port_status[dbg_port - 1]);
+        portsc &= ~PORT_PE;
+        writel(portsc, &ehci_regs->port_status[dbg_port - 1]);
+
+        dbgp_mdelay(100);
+
+try_again:
+        /* Find the debug device and make it device number 127 */
+        for (devnum = 0; devnum <= 127; devnum++) {
+                ret = dbgp_control_msg(devnum,
+                        USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
+                        USB_REQ_GET_DESCRIPTOR, (USB_DT_DEBUG << 8), 0,
+                        &dbgp_desc, sizeof(dbgp_desc));
+                if (ret > 0)
+                        break;
+        }
+        if (devnum > 127) {
+                dbgp_printk("Could not find attached debug device\n");
+                goto err;
+        }
+        if (ret < 0) {
+                dbgp_printk("Attached device is not a debug device\n");
+                goto err;
+        }
+        dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint;
+
+        /* Move the device to 127 if it isn't already there */
+        if (devnum != USB_DEBUG_DEVNUM) {
+                ret = dbgp_control_msg(devnum,
+                        USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
+                        USB_REQ_SET_ADDRESS, USB_DEBUG_DEVNUM, 0, NULL, 0);
+                if (ret < 0) {
+                        dbgp_printk("Could not move attached device to %d\n",
+                                USB_DEBUG_DEVNUM);
+                        goto err;
+                }
+                devnum = USB_DEBUG_DEVNUM;
+                dbgp_printk("debug device renamed to 127\n");
+        }
+
+        /* Enable the debug interface */
+        ret = dbgp_control_msg(USB_DEBUG_DEVNUM,
+                USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
+                USB_REQ_SET_FEATURE, USB_DEVICE_DEBUG_MODE, 0, NULL, 0);
+        if (ret < 0) {
+                dbgp_printk(" Could not enable the debug device\n");
+                goto err;
+        }
+        dbgp_printk("debug interface enabled\n");
+        /* Perform a small write to get the even/odd data state in sync
+         */
+        ret = dbgp_bulk_write(USB_DEBUG_DEVNUM, dbgp_endpoint_out, " ", 1);
+        if (ret < 0) {
+                dbgp_printk("dbgp_bulk_write failed: %d\n", ret);
+                goto err;
+        }
+        dbgp_printk("small write doned\n");
+        dbgp_not_safe = 0;
+
+        return 0;
+err:
+        if (tries--)
+                goto try_again;
+        return -ENODEV;
+}
+EXPORT_SYMBOL_GPL(dbgp_external_startup);
+
+static int __init ehci_reset_port(int port)
+{
+        u32 portsc;
+        u32 delay_time, delay;
+        int loop;
+
+        dbgp_ehci_status("reset port");
+        /* Reset the usb debug port */
+        portsc = readl(&ehci_regs->port_status[port - 1]);
+        portsc &= ~PORT_PE;
+        portsc |= PORT_RESET;
+        writel(portsc, &ehci_regs->port_status[port - 1]);
+
+        delay = HUB_ROOT_RESET_TIME;
+        for (delay_time = 0; delay_time < HUB_RESET_TIMEOUT;
+             delay_time += delay) {
+                dbgp_mdelay(delay);
+                portsc = readl(&ehci_regs->port_status[port - 1]);
+                if (!(portsc & PORT_RESET))
+                        break;
+        }
+                if (portsc & PORT_RESET) {
+                        /* force reset to complete */
+                        loop = 100 * 1000;
+                        writel(portsc & ~(PORT_RWC_BITS | PORT_RESET),
+                                &ehci_regs->port_status[port - 1]);
+                        do {
+                                udelay(1);
+                                portsc = readl(&ehci_regs->port_status[port-1]);
+                        } while ((portsc & PORT_RESET) && (--loop > 0));
+                }
+
+                /* Device went away? */
+                if (!(portsc & PORT_CONNECT))
+                        return -ENOTCONN;
+
+                /* bomb out completely if something weird happend */
+                if ((portsc & PORT_CSC))
+                        return -EINVAL;
+
+                /* If we've finished resetting, then break out of the loop */
+                if (!(portsc & PORT_RESET) && (portsc & PORT_PE))
+                        return 0;
+        return -EBUSY;
+}
+
+static int ehci_wait_for_port(int port)
+{
+        u32 status;
+        int ret, reps;
+
+        for (reps = 0; reps < 300; reps++) {
+                status = readl(&ehci_regs->status);
+                if (status & STS_PCD)
+                        break;
+                dbgp_mdelay(1);
+        }
+        ret = ehci_reset_port(port);
+        if (ret == 0)
+                return 0;
+        return -ENOTCONN;
+}
+
+typedef void (*set_debug_port_t)(int port);
+
+static void __init default_set_debug_port(int port)
+{
+}
+
+static set_debug_port_t __initdata set_debug_port = default_set_debug_port;
+
+static void __init nvidia_set_debug_port(int port)
+{
+        u32 dword;
+        dword = read_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func,
+                                 0x74);
+        dword &= ~(0x0f<<12);
+        dword |= ((port & 0x0f)<<12);
+        write_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func, 0x74,
+                                 dword);
+        dbgp_printk("set debug port to %d\n", port);
+}
+
+static void __init detect_set_debug_port(void)
+{
+        u32 vendorid;
+
+        vendorid = read_pci_config(ehci_dev.bus, ehci_dev.slot, ehci_dev.func,
+                 0x00);
+
+        if ((vendorid & 0xffff) == 0x10de) {
+                dbgp_printk("using nvidia set_debug_port\n");
+                set_debug_port = nvidia_set_debug_port;
+        }
+}
+
+/* The code in early_ehci_bios_handoff() is derived from the usb pci
+ * quirk initialization, but altered so as to use the early PCI
+ * routines. */
+#define EHCI_USBLEGSUP_BIOS     (1 << 16)       /* BIOS semaphore */
+#define EHCI_USBLEGCTLSTS       4               /* legacy control/status */
+static void __init early_ehci_bios_handoff(void)
+{
+        u32 hcc_params = readl(&ehci_caps->hcc_params);
+        int offset = (hcc_params >> 8) & 0xff;
+        u32 cap;
+        int msec;
+
+        if (!offset)
+                return;
+
+        cap = read_pci_config(ehci_dev.bus, ehci_dev.slot,
+                              ehci_dev.func, offset);
+        dbgp_printk("dbgp: ehci BIOS state %08x\n", cap);
+
+        if ((cap & 0xff) == 1 && (cap & EHCI_USBLEGSUP_BIOS)) {
+                dbgp_printk("dbgp: BIOS handoff\n");
+                write_pci_config_byte(ehci_dev.bus, ehci_dev.slot,
+                                      ehci_dev.func, offset + 3, 1);
+        }
+
+        /* if boot firmware now owns EHCI, spin till it hands it over. */
+        msec = 1000;
+        while ((cap & EHCI_USBLEGSUP_BIOS) && (msec > 0)) {
+                mdelay(10);
+                msec -= 10;
+                cap = read_pci_config(ehci_dev.bus, ehci_dev.slot,
+                                      ehci_dev.func, offset);
+        }
+
+        if (cap & EHCI_USBLEGSUP_BIOS) {
+                /* well, possibly buggy BIOS... try to shut it down,
+                 * and hope nothing goes too wrong */
+                dbgp_printk("dbgp: BIOS handoff failed: %08x\n", cap);
+                write_pci_config_byte(ehci_dev.bus, ehci_dev.slot,
+                                      ehci_dev.func, offset + 2, 0);
+        }
+
+        /* just in case, always disable EHCI SMIs */
+        write_pci_config_byte(ehci_dev.bus, ehci_dev.slot, ehci_dev.func,
+                              offset + EHCI_USBLEGCTLSTS, 0);
+}
+
+static int __init ehci_setup(void)
+{
+        u32 ctrl, portsc, hcs_params;
+        u32 debug_port, new_debug_port = 0, n_ports;
+        int ret, i;
+        int port_map_tried;
+        int playtimes = 3;
+
+        early_ehci_bios_handoff();
+
+try_next_time:
+        port_map_tried = 0;
+
+try_next_port:
+
+        hcs_params = readl(&ehci_caps->hcs_params);
+        debug_port = HCS_DEBUG_PORT(hcs_params);
+        dbgp_phys_port = debug_port;
+        n_ports    = HCS_N_PORTS(hcs_params);
+
+        dbgp_printk("debug_port: %d\n", debug_port);
+        dbgp_printk("n_ports:    %d\n", n_ports);
+        dbgp_ehci_status("");
+
+        for (i = 1; i <= n_ports; i++) {
+                portsc = readl(&ehci_regs->port_status[i-1]);
+                dbgp_printk("portstatus%d: %08x\n", i, portsc);
+        }
+
+        if (port_map_tried && (new_debug_port != debug_port)) {
+                if (--playtimes) {
+                        set_debug_port(new_debug_port);
+                        goto try_next_time;
+                }
+                return -1;
+        }
+
+        /* Only reset the controller if it is not already in the
+         * configured state */
+        if (!(readl(&ehci_regs->configured_flag) & FLAG_CF)) {
+                if (dbgp_ehci_controller_reset() != 0)
+                        return -1;
+        } else {
+                dbgp_ehci_status("ehci skip - already configured");
+        }
+
+        ret = dbgp_external_startup();
+        if (ret == -EIO)
+                goto next_debug_port;
+
+        if (ret < 0) {
+                /* Things didn't work so remove my claim */
+                ctrl = readl(&ehci_debug->control);
+                ctrl &= ~(DBGP_CLAIM | DBGP_OUT);
+                writel(ctrl, &ehci_debug->control);
+                return -1;
+        }
+        return 0;
+
+next_debug_port:
+        port_map_tried |= (1<<(debug_port - 1));
+        new_debug_port = ((debug_port-1+1)%n_ports) + 1;
+        if (port_map_tried != ((1<<n_ports) - 1)) {
+                set_debug_port(new_debug_port);
+                goto try_next_port;
+        }
+        if (--playtimes) {
+                set_debug_port(new_debug_port);
+                goto try_next_time;
+        }
+
+        return -1;
+}
+
+int __init early_dbgp_init(char *s)
+{
+        u32 debug_port, bar, offset;
+        u32 bus, slot, func, cap;
+        void __iomem *ehci_bar;
+        u32 dbgp_num;
+        u32 bar_val;
+        char *e;
+        int ret;
+        u8 byte;
+
+        if (!early_pci_allowed())
+                return -1;
+
+        dbgp_num = 0;
+        if (*s)
+                dbgp_num = simple_strtoul(s, &e, 10);
+        dbgp_printk("dbgp_num: %d\n", dbgp_num);
+
+        cap = find_dbgp(dbgp_num, &bus, &slot, &func);
+        if (!cap)
+                return -1;
+
+        dbgp_printk("Found EHCI debug port on %02x:%02x.%1x\n", bus, slot,
+                         func);
+
+        debug_port = read_pci_config(bus, slot, func, cap);
+        bar = (debug_port >> 29) & 0x7;
+        bar = (bar * 4) + 0xc;
+        offset = (debug_port >> 16) & 0xfff;
+        dbgp_printk("bar: %02x offset: %03x\n", bar, offset);
+        if (bar != PCI_BASE_ADDRESS_0) {
+                dbgp_printk("only debug ports on bar 1 handled.\n");
+
+                return -1;
+        }
+
+        bar_val = read_pci_config(bus, slot, func, PCI_BASE_ADDRESS_0);
+        dbgp_printk("bar_val: %02x offset: %03x\n", bar_val, offset);
+        if (bar_val & ~PCI_BASE_ADDRESS_MEM_MASK) {
+                dbgp_printk("only simple 32bit mmio bars supported\n");
+
+                return -1;
+        }
+
+        /* double check if the mem space is enabled */
+        byte = read_pci_config_byte(bus, slot, func, 0x04);
+        if (!(byte & 0x2)) {
+                byte  |= 0x02;
+                write_pci_config_byte(bus, slot, func, 0x04, byte);
+                dbgp_printk("mmio for ehci enabled\n");
+        }
+
+        /*
+         * FIXME I don't have the bar size so just guess PAGE_SIZE is more
+         * than enough.  1K is the biggest I have seen.
+         */
+        set_fixmap_nocache(FIX_DBGP_BASE, bar_val & PAGE_MASK);
+        ehci_bar = (void __iomem *)__fix_to_virt(FIX_DBGP_BASE);
+        ehci_bar += bar_val & ~PAGE_MASK;
+        dbgp_printk("ehci_bar: %p\n", ehci_bar);
+
+        ehci_caps  = ehci_bar;
+        ehci_regs  = ehci_bar + HC_LENGTH(readl(&ehci_caps->hc_capbase));
+        ehci_debug = ehci_bar + offset;
+        ehci_dev.bus = bus;
+        ehci_dev.slot = slot;
+        ehci_dev.func = func;
+
+        detect_set_debug_port();
+
+        ret = ehci_setup();
+        if (ret < 0) {
+                dbgp_printk("ehci_setup failed\n");
+                ehci_debug = NULL;
+
+                return -1;
+        }
+        dbgp_ehci_status("early_init_complete");
+
+        return 0;
+}
+
+static void early_dbgp_write(struct console *con, const char *str, u32 n)
+{
+        int chunk, ret;
+        char buf[DBGP_MAX_PACKET];
+        int use_cr = 0;
+        u32 cmd, ctrl;
+        int reset_run = 0;
+
+        if (!ehci_debug || dbgp_not_safe)
+                return;
+
+        cmd = readl(&ehci_regs->command);
+        if (unlikely(!(cmd & CMD_RUN))) {
+                /* If the ehci controller is not in the run state do extended
+                 * checks to see if the acpi or some other initialization also
+                 * reset the ehci debug port */
+                ctrl = readl(&ehci_debug->control);
+                if (!(ctrl & DBGP_ENABLED)) {
+                        dbgp_not_safe = 1;
+                        dbgp_external_startup();
+                } else {
+                        cmd |= CMD_RUN;
+                        writel(cmd, &ehci_regs->command);
+                        reset_run = 1;
+                }
+        }
+        while (n > 0) {
+                for (chunk = 0; chunk < DBGP_MAX_PACKET && n > 0;
+                     str++, chunk++, n--) {
+                        if (!use_cr && *str == '\n') {
+                                use_cr = 1;
+                                buf[chunk] = '\r';
+                                str--;
+                                n++;
+                                continue;
+                        }
+                        if (use_cr)
+                                use_cr = 0;
+                        buf[chunk] = *str;
+                }
+                if (chunk > 0) {
+                        ret = dbgp_bulk_write(USB_DEBUG_DEVNUM,
+                                      dbgp_endpoint_out, buf, chunk);
+                }
+        }
+        if (unlikely(reset_run)) {
+                cmd = readl(&ehci_regs->command);
+                cmd &= ~CMD_RUN;
+                writel(cmd, &ehci_regs->command);
+        }
+}
+
+struct console early_dbgp_console = {
+        .name =         "earlydbg",
+        .write =        early_dbgp_write,
+        .flags =        CON_PRINTBUFFER,
+        .index =        -1,
+};
+
+int dbgp_reset_prep(void)
+{
+        u32 ctrl;
+
+        dbgp_not_safe = 1;
+        if (!ehci_debug)
+                return 0;
+
+        if (early_dbgp_console.index != -1 &&
+                !(early_dbgp_console.flags & CON_BOOT))
+                return 1;
+        /* This means the console is not initialized, or should get
+         * shutdown so as to allow for reuse of the usb device, which
+         * means it is time to shutdown the usb debug port. */
+        ctrl = readl(&ehci_debug->control);
+        if (ctrl & DBGP_ENABLED) {
+                ctrl &= ~(DBGP_CLAIM);
+                writel(ctrl, &ehci_debug->control);
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(dbgp_reset_prep);
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 9f986b417c5b..33351312327f 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -124,7 +124,7 @@ choice
 
 config USB_GADGET_AT91
         boolean "Atmel AT91 USB Device Port"
-        depends on ARCH_AT91 && !ARCH_AT91SAM9RL && !ARCH_AT91CAP9
+        depends on ARCH_AT91 && !ARCH_AT91SAM9RL && !ARCH_AT91CAP9 && !ARCH_AT91SAM9G45
         select USB_GADGET_SELECTED
         help
            Many Atmel AT91 processors (such as the AT91RM2000) have a
@@ -143,7 +143,7 @@ config USB_AT91
 config USB_GADGET_ATMEL_USBA
         boolean "Atmel USBA"
         select USB_GADGET_DUALSPEED
-        depends on AVR32 || ARCH_AT91CAP9 || ARCH_AT91SAM9RL
+        depends on AVR32 || ARCH_AT91CAP9 || ARCH_AT91SAM9RL || ARCH_AT91SAM9G45
         help
           USBA is the integrated high-speed USB Device controller on
           the AT32AP700x, some AT91SAM9 and AT91CAP9 processors from Atmel.
@@ -627,9 +627,10 @@ config USB_AUDIO
 config USB_ETH
         tristate "Ethernet Gadget (with CDC Ethernet support)"
         depends on NET
+        select CRC32
         help
-          This driver implements Ethernet style communication, in either
-          of two ways:
+          This driver implements Ethernet style communication, in one of
+          several ways:
           
            - The "Communication Device Class" (CDC) Ethernet Control Model.
              That protocol is often avoided with pure Ethernet adapters, in
@@ -639,7 +640,11 @@ config USB_ETH
            - On hardware can't implement that protocol, a simple CDC subset
              is used, placing fewer demands on USB.
 
-          RNDIS support is a third option, more demanding than that subset.
+           - CDC Ethernet Emulation Model (EEM) is a newer standard that has
+             a simpler interface that can be used by more USB hardware.
+
+          RNDIS support is an additional option, more demanding than than
+          subset.
 
           Within the USB device, this gadget driver exposes a network device
           "usbX", where X depends on what other networking devices you have.
@@ -672,6 +677,22 @@ config USB_ETH_RNDIS
            XP, you'll need to download drivers from Microsoft's website; a URL
            is given in comments found in that info file.
 
+config USB_ETH_EEM
+       bool "Ethernet Emulation Model (EEM) support"
+       depends on USB_ETH
+       default n
+       help
+         CDC EEM is a newer USB standard that is somewhat simpler than CDC ECM
+         and therefore can be supported by more hardware.  Technically ECM and
+         EEM are designed for different applications.  The ECM model extends
+         the network interface to the target (e.g. a USB cable modem), and the
+         EEM model is for mobile devices to communicate with hosts using
+         ethernet over USB.  For Linux gadgets, however, the interface with
+         the host is the same (a usbX device), so the differences are minimal.
+
+         If you say "y" here, the Ethernet gadget driver will use the EEM
+         protocol rather than ECM.  If unsure, say "n".
+
 config USB_GADGETFS
         tristate "Gadget Filesystem (EXPERIMENTAL)"
         depends on EXPERIMENTAL
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index 77352ccc245e..d5b65962dd36 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -2378,40 +2378,34 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int ep_ix)
                 if (!ep->cancel_transfer && !list_empty(&ep->queue)) {
                         req = list_entry(ep->queue.next,
                                         struct udc_request, queue);
-                        if (req) {
-                                /*
-                                 * length bytes transfered
-                                 * check dma done of last desc. in PPBDU mode
-                                 */
-                                if (use_dma_ppb_du) {
-                                        td = udc_get_last_dma_desc(req);
-                                        if (td) {
-                                                dma_done =
-                                                        AMD_GETBITS(td->status,
-                                                        UDC_DMA_IN_STS_BS);
-                                                /* don't care DMA done */
-                                                req->req.actual =
-                                                        req->req.length;
-                                        }
-                                } else {
-                                        /* assume all bytes transferred */
+                        /*
+                         * length bytes transfered
+                         * check dma done of last desc. in PPBDU mode
+                         */
+                        if (use_dma_ppb_du) {
+                                td = udc_get_last_dma_desc(req);
+                                if (td) {
+                                        dma_done =
+                                                AMD_GETBITS(td->status,
+                                                UDC_DMA_IN_STS_BS);
+                                        /* don't care DMA done */
                                         req->req.actual = req->req.length;
                                 }
+                        } else {
+                                /* assume all bytes transferred */
+                                req->req.actual = req->req.length;
+                        }
 
-                                if (req->req.actual == req->req.length) {
-                                        /* complete req */
-                                        complete_req(ep, req, 0);
-                                        req->dma_going = 0;
-                                        /* further request available ? */
-                                        if (list_empty(&ep->queue)) {
-                                                /* disable interrupt */
-                                                tmp = readl(
-                                                        &dev->regs->ep_irqmsk);
-                                                tmp |= AMD_BIT(ep->num);
-                                                writel(tmp,
-                                                        &dev->regs->ep_irqmsk);
-                                        }
-
+                        if (req->req.actual == req->req.length) {
+                                /* complete req */
+                                complete_req(ep, req, 0);
+                                req->dma_going = 0;
+                                /* further request available ? */
+                                if (list_empty(&ep->queue)) {
+                                        /* disable interrupt */
+                                        tmp = readl(&dev->regs->ep_irqmsk);
+                                        tmp |= AMD_BIT(ep->num);
+                                        writel(tmp, &dev->regs->ep_irqmsk);
                                 }
                         }
                 }
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 72bae8f39d81..66450a1abc22 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -1754,7 +1754,6 @@ static int __init at91udc_probe(struct platform_device *pdev)
                                 IRQF_DISABLED, driver_name, udc)) {
                         DBG("request vbus irq %d failed\n",
                                         udc->board.vbus_pin);
-                        free_irq(udc->udp_irq, udc);
                         retval = -EBUSY;
                         goto fail3;
                 }
diff --git a/drivers/usb/gadget/audio.c b/drivers/usb/gadget/audio.c
index 9f80f4e970bd..a3a0f4a27ef0 100644
--- a/drivers/usb/gadget/audio.c
+++ b/drivers/usb/gadget/audio.c
@@ -106,20 +106,20 @@ static int audio_set_endpoint_req(struct usb_configuration *c,
                         ctrl->bRequest, w_value, len, ep);
 
         switch (ctrl->bRequest) {
-        case SET_CUR:
+        case UAC_SET_CUR:
                 value = 0;
                 break;
 
-        case SET_MIN:
+        case UAC_SET_MIN:
                 break;
 
-        case SET_MAX:
+        case UAC_SET_MAX:
                 break;
 
-        case SET_RES:
+        case UAC_SET_RES:
                 break;
 
-        case SET_MEM:
+        case UAC_SET_MEM:
                 break;
 
         default:
@@ -142,13 +142,13 @@ static int audio_get_endpoint_req(struct usb_configuration *c,
                         ctrl->bRequest, w_value, len, ep);
 
         switch (ctrl->bRequest) {
-        case GET_CUR:
-        case GET_MIN:
-        case GET_MAX:
-        case GET_RES:
+        case UAC_GET_CUR:
+        case UAC_GET_MIN:
+        case UAC_GET_MAX:
+        case UAC_GET_RES:
                 value = 3;
                 break;
-        case GET_MEM:
+        case UAC_GET_MEM:
                 break;
         default:
                 break;
@@ -171,11 +171,11 @@ audio_setup(struct usb_configuration *c, const struct usb_ctrlrequest *ctrl)
          * Audio class messages; interface activation uses set_alt().
          */
         switch (ctrl->bRequestType) {
-        case USB_AUDIO_SET_ENDPOINT:
+        case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
                 value = audio_set_endpoint_req(c, ctrl);
                 break;
 
-        case USB_AUDIO_GET_ENDPOINT:
+        case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
                 value = audio_get_endpoint_req(c, ctrl);
                 break;
 
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 59e85234fa0a..d05397ec8a18 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -602,7 +602,7 @@ static int get_string(struct usb_composite_dev *cdev,
                         }
                 }
 
-                for (len = 0; s->wData[len] && len <= 126; len++)
+                for (len = 0; len <= 126 && s->wData[len]; len++)
                         continue;
                 if (!len)
                         return -EINVAL;
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index a56b24d305f8..5e0966485188 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -1306,11 +1306,6 @@ restart:
                         setup = *(struct usb_ctrlrequest*) urb->setup_packet;
                         w_index = le16_to_cpu(setup.wIndex);
                         w_value = le16_to_cpu(setup.wValue);
-                        if (le16_to_cpu(setup.wLength) !=
-                                        urb->transfer_buffer_length) {
-                                status = -EOVERFLOW;
-                                goto return_urb;
-                        }
 
                         /* paranoia, in case of stale queued data */
                         list_for_each_entry (req, &ep->queue, queue) {
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index bd102f5052ba..f37de283d0ab 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -61,6 +61,11 @@
  * simpler, Microsoft pushes their own approach: RNDIS.  The published
  * RNDIS specs are ambiguous and appear to be incomplete, and are also
  * needlessly complex.  They borrow more from CDC ACM than CDC ECM.
+ *
+ * While CDC ECM, CDC Subset, and RNDIS are designed to extend the ethernet
+ * interface to the target, CDC EEM was designed to use ethernet over the USB
+ * link between the host and target.  CDC EEM is implemented as an alternative
+ * to those other protocols when that communication model is more appropriate
  */
 
 #define DRIVER_DESC             "Ethernet Gadget"
@@ -114,6 +119,7 @@ static inline bool has_rndis(void)
 #include "f_rndis.c"
 #include "rndis.c"
 #endif
+#include "f_eem.c"
 #include "u_ether.c"
 
 /*-------------------------------------------------------------------------*/
@@ -150,6 +156,10 @@ static inline bool has_rndis(void)
 #define RNDIS_VENDOR_NUM        0x0525  /* NetChip */
 #define RNDIS_PRODUCT_NUM       0xa4a2  /* Ethernet/RNDIS Gadget */
 
+/* For EEM gadgets */
+#define EEM_VENDOR_NUM  0x0525  /* INVALID - NEEDS TO BE ALLOCATED */
+#define EEM_PRODUCT_NUM 0xa4a1  /* INVALID - NEEDS TO BE ALLOCATED */
+
 /*-------------------------------------------------------------------------*/
 
 static struct usb_device_descriptor device_desc = {
@@ -246,8 +256,16 @@ static struct usb_configuration rndis_config_driver = {
 
 /*-------------------------------------------------------------------------*/
 
+#ifdef CONFIG_USB_ETH_EEM
+static int use_eem = 1;
+#else
+static int use_eem;
+#endif
+module_param(use_eem, bool, 0);
+MODULE_PARM_DESC(use_eem, "use CDC EEM mode");
+
 /*
- * We _always_ have an ECM or CDC Subset configuration.
+ * We _always_ have an ECM, CDC Subset, or EEM configuration.
  */
 static int __init eth_do_config(struct usb_configuration *c)
 {
@@ -258,7 +276,9 @@ static int __init eth_do_config(struct usb_configuration *c)
                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        if (can_support_ecm(c->cdev->gadget))
+        if (use_eem)
+                return eem_bind_config(c);
+        else if (can_support_ecm(c->cdev->gadget))
                 return ecm_bind_config(c, hostaddr);
         else
                 return geth_bind_config(c, hostaddr);
@@ -286,7 +306,12 @@ static int __init eth_bind(struct usb_composite_dev *cdev)
                 return status;
 
         /* set up main config label and device descriptor */
-        if (can_support_ecm(cdev->gadget)) {
+        if (use_eem) {
+                /* EEM */
+                eth_config_driver.label = "CDC Ethernet (EEM)";
+                device_desc.idVendor = cpu_to_le16(EEM_VENDOR_NUM);
+                device_desc.idProduct = cpu_to_le16(EEM_PRODUCT_NUM);
+        } else if (can_support_ecm(cdev->gadget)) {
                 /* ECM */
                 eth_config_driver.label = "CDC Ethernet (ECM)";
         } else {
diff --git a/drivers/usb/gadget/f_audio.c b/drivers/usb/gadget/f_audio.c
index 66527ba2d2ea..98e9bb977291 100644
--- a/drivers/usb/gadget/f_audio.c
+++ b/drivers/usb/gadget/f_audio.c
@@ -28,6 +28,9 @@ static int audio_buf_size = 48000;
 module_param(audio_buf_size, int, S_IRUGO);
 MODULE_PARM_DESC(audio_buf_size, "Audio buffer size");
 
+static int generic_set_cmd(struct usb_audio_control *con, u8 cmd, int value);
+static int generic_get_cmd(struct usb_audio_control *con, u8 cmd);
+
 /*
  * DESCRIPTORS ... most are static, but strings and full
  * configuration descriptors are built on demand.
@@ -50,16 +53,16 @@ static struct usb_interface_descriptor ac_interface_desc __initdata = {
         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOCONTROL,
 };
 
-DECLARE_USB_AC_HEADER_DESCRIPTOR(2);
+DECLARE_UAC_AC_HEADER_DESCRIPTOR(2);
 
-#define USB_DT_AC_HEADER_LENGH  USB_DT_AC_HEADER_SIZE(F_AUDIO_NUM_INTERFACES)
+#define UAC_DT_AC_HEADER_LENGTH UAC_DT_AC_HEADER_SIZE(F_AUDIO_NUM_INTERFACES)
 /* B.3.2  Class-Specific AC Interface Descriptor */
-static struct usb_ac_header_descriptor_2 ac_header_desc = {
-        .bLength =              USB_DT_AC_HEADER_LENGH,
+static struct uac_ac_header_descriptor_2 ac_header_desc = {
+        .bLength =              UAC_DT_AC_HEADER_LENGTH,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubtype =   HEADER,
+        .bDescriptorSubtype =   UAC_HEADER,
         .bcdADC =               __constant_cpu_to_le16(0x0100),
-        .wTotalLength =         __constant_cpu_to_le16(USB_DT_AC_HEADER_LENGH),
+        .wTotalLength =         __constant_cpu_to_le16(UAC_DT_AC_HEADER_LENGTH),
         .bInCollection =        F_AUDIO_NUM_INTERFACES,
         .baInterfaceNr = {
                 [0] =           F_AUDIO_AC_INTERFACE,
@@ -68,33 +71,33 @@ static struct usb_ac_header_descriptor_2 ac_header_desc = {
 };
 
 #define INPUT_TERMINAL_ID       1
-static struct usb_input_terminal_descriptor input_terminal_desc = {
-        .bLength =              USB_DT_AC_INPUT_TERMINAL_SIZE,
+static struct uac_input_terminal_descriptor input_terminal_desc = {
+        .bLength =              UAC_DT_INPUT_TERMINAL_SIZE,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubtype =   INPUT_TERMINAL,
+        .bDescriptorSubtype =   UAC_INPUT_TERMINAL,
         .bTerminalID =          INPUT_TERMINAL_ID,
-        .wTerminalType =        USB_AC_TERMINAL_STREAMING,
+        .wTerminalType =        UAC_TERMINAL_STREAMING,
         .bAssocTerminal =       0,
         .wChannelConfig =       0x3,
 };
 
-DECLARE_USB_AC_FEATURE_UNIT_DESCRIPTOR(0);
+DECLARE_UAC_FEATURE_UNIT_DESCRIPTOR(0);
 
 #define FEATURE_UNIT_ID         2
-static struct usb_ac_feature_unit_descriptor_0 feature_unit_desc = {
-        .bLength                = USB_DT_AC_FEATURE_UNIT_SIZE(0),
+static struct uac_feature_unit_descriptor_0 feature_unit_desc = {
+        .bLength                = UAC_DT_FEATURE_UNIT_SIZE(0),
         .bDescriptorType        = USB_DT_CS_INTERFACE,
-        .bDescriptorSubtype     = FEATURE_UNIT,
+        .bDescriptorSubtype     = UAC_FEATURE_UNIT,
         .bUnitID                = FEATURE_UNIT_ID,
         .bSourceID              = INPUT_TERMINAL_ID,
         .bControlSize           = 2,
-        .bmaControls[0]         = (FU_MUTE | FU_VOLUME),
+        .bmaControls[0]         = (UAC_FU_MUTE | UAC_FU_VOLUME),
 };
 
 static struct usb_audio_control mute_control = {
         .list = LIST_HEAD_INIT(mute_control.list),
         .name = "Mute Control",
-        .type = MUTE_CONTROL,
+        .type = UAC_MUTE_CONTROL,
         /* Todo: add real Mute control code */
         .set = generic_set_cmd,
         .get = generic_get_cmd,
@@ -103,7 +106,7 @@ static struct usb_audio_control mute_control = {
 static struct usb_audio_control volume_control = {
         .list = LIST_HEAD_INIT(volume_control.list),
         .name = "Volume Control",
-        .type = VOLUME_CONTROL,
+        .type = UAC_VOLUME_CONTROL,
         /* Todo: add real Volume control code */
         .set = generic_set_cmd,
         .get = generic_get_cmd,
@@ -113,17 +116,17 @@ static struct usb_audio_control_selector feature_unit = {
         .list = LIST_HEAD_INIT(feature_unit.list),
         .id = FEATURE_UNIT_ID,
         .name = "Mute & Volume Control",
-        .type = FEATURE_UNIT,
+        .type = UAC_FEATURE_UNIT,
         .desc = (struct usb_descriptor_header *)&feature_unit_desc,
 };
 
 #define OUTPUT_TERMINAL_ID      3
-static struct usb_output_terminal_descriptor output_terminal_desc = {
-        .bLength                = USB_DT_AC_OUTPUT_TERMINAL_SIZE,
+static struct uac_output_terminal_descriptor output_terminal_desc = {
+        .bLength                = UAC_DT_OUTPUT_TERMINAL_SIZE,
         .bDescriptorType        = USB_DT_CS_INTERFACE,
-        .bDescriptorSubtype     = OUTPUT_TERMINAL,
+        .bDescriptorSubtype     = UAC_OUTPUT_TERMINAL,
         .bTerminalID            = OUTPUT_TERMINAL_ID,
-        .wTerminalType          = USB_AC_OUTPUT_TERMINAL_SPEAKER,
+        .wTerminalType          = UAC_OUTPUT_TERMINAL_SPEAKER,
         .bAssocTerminal         = FEATURE_UNIT_ID,
         .bSourceID              = FEATURE_UNIT_ID,
 };
@@ -148,22 +151,22 @@ static struct usb_interface_descriptor as_interface_alt_1_desc = {
 };
 
 /* B.4.2  Class-Specific AS Interface Descriptor */
-static struct usb_as_header_descriptor as_header_desc = {
-        .bLength =              USB_DT_AS_HEADER_SIZE,
+static struct uac_as_header_descriptor as_header_desc = {
+        .bLength =              UAC_DT_AS_HEADER_SIZE,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubtype =   AS_GENERAL,
+        .bDescriptorSubtype =   UAC_AS_GENERAL,
         .bTerminalLink =        INPUT_TERMINAL_ID,
         .bDelay =               1,
-        .wFormatTag =           USB_AS_AUDIO_FORMAT_TYPE_I_PCM,
+        .wFormatTag =           UAC_FORMAT_TYPE_I_PCM,
 };
 
-DECLARE_USB_AS_FORMAT_TYPE_I_DISCRETE_DESC(1);
+DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(1);
 
-static struct usb_as_formate_type_i_discrete_descriptor_1 as_type_i_desc = {
-        .bLength =              USB_AS_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
+static struct uac_format_type_i_discrete_descriptor_1 as_type_i_desc = {
+        .bLength =              UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
         .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubtype =   FORMAT_TYPE,
-        .bFormatType =          USB_AS_FORMAT_TYPE_I,
+        .bDescriptorSubtype =   UAC_FORMAT_TYPE,
+        .bFormatType =          UAC_FORMAT_TYPE_I,
         .bSubframeSize =        2,
         .bBitResolution =       16,
         .bSamFreqType =         1,
@@ -174,17 +177,17 @@ static struct usb_endpoint_descriptor as_out_ep_desc __initdata = {
         .bLength =              USB_DT_ENDPOINT_AUDIO_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
         .bEndpointAddress =     USB_DIR_OUT,
-        .bmAttributes =         USB_AS_ENDPOINT_ADAPTIVE
+        .bmAttributes =         USB_ENDPOINT_SYNC_ADAPTIVE
                                 | USB_ENDPOINT_XFER_ISOC,
         .wMaxPacketSize =       __constant_cpu_to_le16(OUT_EP_MAX_PACKET_SIZE),
         .bInterval =            4,
 };
 
 /* Class-specific AS ISO OUT Endpoint Descriptor */
-static struct usb_as_iso_endpoint_descriptor as_iso_out_desc __initdata = {
-        .bLength =              USB_AS_ISO_ENDPOINT_DESC_SIZE,
+static struct uac_iso_endpoint_descriptor as_iso_out_desc __initdata = {
+        .bLength =              UAC_ISO_ENDPOINT_DESC_SIZE,
         .bDescriptorType =      USB_DT_CS_ENDPOINT,
-        .bDescriptorSubtype =   EP_GENERAL,
+        .bDescriptorSubtype =   UAC_EP_GENERAL,
         .bmAttributes =         1,
         .bLockDelayUnits =      1,
         .wLockDelay =           __constant_cpu_to_le16(1),
@@ -456,11 +459,11 @@ f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
          * Audio class messages; interface activation uses set_alt().
          */
         switch (ctrl->bRequestType) {
-        case USB_AUDIO_SET_INTF:
+        case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
                 value = audio_set_intf_req(f, ctrl);
                 break;
 
-        case USB_AUDIO_GET_INTF:
+        case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
                 value = audio_get_intf_req(f, ctrl);
                 break;
 
@@ -632,6 +635,18 @@ f_audio_unbind(struct usb_configuration *c, struct usb_function *f)
 
 /*-------------------------------------------------------------------------*/
 
+static int generic_set_cmd(struct usb_audio_control *con, u8 cmd, int value)
+{
+        con->data[cmd] = value;
+
+        return 0;
+}
+
+static int generic_get_cmd(struct usb_audio_control *con, u8 cmd)
+{
+        return con->data[cmd];
+}
+
 /* Todo: add more control selecotor dynamically */
 int __init control_selector_init(struct f_audio *audio)
 {
@@ -642,10 +657,10 @@ int __init control_selector_init(struct f_audio *audio)
         list_add(&mute_control.list, &feature_unit.control);
         list_add(&volume_control.list, &feature_unit.control);
 
-        volume_control.data[_CUR] = 0xffc0;
-        volume_control.data[_MIN] = 0xe3a0;
-        volume_control.data[_MAX] = 0xfff0;
-        volume_control.data[_RES] = 0x0030;
+        volume_control.data[UAC__CUR] = 0xffc0;
+        volume_control.data[UAC__MIN] = 0xe3a0;
+        volume_control.data[UAC__MAX] = 0xfff0;
+        volume_control.data[UAC__RES] = 0x0030;
 
         return 0;
 }
diff --git a/drivers/usb/gadget/f_eem.c b/drivers/usb/gadget/f_eem.c
new file mode 100644
index 000000000000..0a577d5694fd
--- /dev/null
+++ b/drivers/usb/gadget/f_eem.c
@@ -0,0 +1,562 @@
+/*
+ * f_eem.c -- USB CDC Ethernet (EEM) link function driver
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2008 Nokia Corporation
+ * Copyright (C) 2009 EF Johnson Technologies
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/etherdevice.h>
+#include <linux/crc32.h>
+
+#include "u_ether.h"
+
+#define EEM_HLEN 2
+
+/*
+ * This function is a "CDC Ethernet Emulation Model" (CDC EEM)
+ * Ethernet link.
+ */
+
+struct eem_ep_descs {
+        struct usb_endpoint_descriptor  *in;
+        struct usb_endpoint_descriptor  *out;
+};
+
+struct f_eem {
+        struct gether                   port;
+        u8                              ctrl_id;
+
+        struct eem_ep_descs             fs;
+        struct eem_ep_descs             hs;
+};
+
+static inline struct f_eem *func_to_eem(struct usb_function *f)
+{
+        return container_of(f, struct f_eem, port.func);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* interface descriptor: */
+
+static struct usb_interface_descriptor eem_intf __initdata = {
+        .bLength =              sizeof eem_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        /* .bInterfaceNumber = DYNAMIC */
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_COMM,
+        .bInterfaceSubClass =   USB_CDC_SUBCLASS_EEM,
+        .bInterfaceProtocol =   USB_CDC_PROTO_EEM,
+        /* .iInterface = DYNAMIC */
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor eem_fs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor eem_fs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *eem_fs_function[] __initdata = {
+        /* CDC EEM control descriptors */
+        (struct usb_descriptor_header *) &eem_intf,
+        (struct usb_descriptor_header *) &eem_fs_in_desc,
+        (struct usb_descriptor_header *) &eem_fs_out_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor eem_hs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor eem_hs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *eem_hs_function[] __initdata = {
+        /* CDC EEM control descriptors */
+        (struct usb_descriptor_header *) &eem_intf,
+        (struct usb_descriptor_header *) &eem_hs_in_desc,
+        (struct usb_descriptor_header *) &eem_hs_out_desc,
+        NULL,
+};
+
+/* string descriptors: */
+
+static struct usb_string eem_string_defs[] = {
+        [0].s = "CDC Ethernet Emulation Model (EEM)",
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings eem_string_table = {
+        .language =             0x0409, /* en-us */
+        .strings =              eem_string_defs,
+};
+
+static struct usb_gadget_strings *eem_strings[] = {
+        &eem_string_table,
+        NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int eem_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+{
+        struct usb_composite_dev *cdev = f->config->cdev;
+        int                     value = -EOPNOTSUPP;
+        u16                     w_index = le16_to_cpu(ctrl->wIndex);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+        u16                     w_length = le16_to_cpu(ctrl->wLength);
+
+        DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
+                ctrl->bRequestType, ctrl->bRequest,
+                w_value, w_index, w_length);
+
+        /* device either stalls (value < 0) or reports success */
+        return value;
+}
+
+
+static int eem_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+        struct f_eem            *eem = func_to_eem(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+        struct net_device       *net;
+
+        /* we know alt == 0, so this is an activation or a reset */
+        if (alt != 0)
+                goto fail;
+
+        if (intf == eem->ctrl_id) {
+
+                if (eem->port.in_ep->driver_data) {
+                        DBG(cdev, "reset eem\n");
+                        gether_disconnect(&eem->port);
+                }
+
+                if (!eem->port.in) {
+                        DBG(cdev, "init eem\n");
+                        eem->port.in = ep_choose(cdev->gadget,
+                                        eem->hs.in, eem->fs.in);
+                        eem->port.out = ep_choose(cdev->gadget,
+                                        eem->hs.out, eem->fs.out);
+                }
+
+                /* zlps should not occur because zero-length EEM packets
+                 * will be inserted in those cases where they would occur
+                 */
+                eem->port.is_zlp_ok = 1;
+                eem->port.cdc_filter = DEFAULT_FILTER;
+                DBG(cdev, "activate eem\n");
+                net = gether_connect(&eem->port);
+                if (IS_ERR(net))
+                        return PTR_ERR(net);
+        } else
+                goto fail;
+
+        return 0;
+fail:
+        return -EINVAL;
+}
+
+static void eem_disable(struct usb_function *f)
+{
+        struct f_eem            *eem = func_to_eem(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        DBG(cdev, "eem deactivated\n");
+
+        if (eem->port.in_ep->driver_data)
+                gether_disconnect(&eem->port);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* EEM function driver setup/binding */
+
+static int __init
+eem_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_eem            *eem = func_to_eem(f);
+        int                     status;
+        struct usb_ep           *ep;
+
+        /* allocate instance-specific interface IDs */
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        eem->ctrl_id = status;
+        eem_intf.bInterfaceNumber = status;
+
+        status = -ENODEV;
+
+        /* allocate instance-specific endpoints */
+        ep = usb_ep_autoconfig(cdev->gadget, &eem_fs_in_desc);
+        if (!ep)
+                goto fail;
+        eem->port.in_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &eem_fs_out_desc);
+        if (!ep)
+                goto fail;
+        eem->port.out_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        status = -ENOMEM;
+
+        /* copy descriptors, and track endpoint copies */
+        f->descriptors = usb_copy_descriptors(eem_fs_function);
+        if (!f->descriptors)
+                goto fail;
+
+        eem->fs.in = usb_find_endpoint(eem_fs_function,
+                        f->descriptors, &eem_fs_in_desc);
+        eem->fs.out = usb_find_endpoint(eem_fs_function,
+                        f->descriptors, &eem_fs_out_desc);
+
+        /* support all relevant hardware speeds... we expect that when
+         * hardware is dual speed, all bulk-capable endpoints work at
+         * both speeds
+         */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                eem_hs_in_desc.bEndpointAddress =
+                                eem_fs_in_desc.bEndpointAddress;
+                eem_hs_out_desc.bEndpointAddress =
+                                eem_fs_out_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->hs_descriptors = usb_copy_descriptors(eem_hs_function);
+                if (!f->hs_descriptors)
+                        goto fail;
+
+                eem->hs.in = usb_find_endpoint(eem_hs_function,
+                                f->hs_descriptors, &eem_hs_in_desc);
+                eem->hs.out = usb_find_endpoint(eem_hs_function,
+                                f->hs_descriptors, &eem_hs_out_desc);
+        }
+
+        DBG(cdev, "CDC Ethernet (EEM): %s speed IN/%s OUT/%s\n",
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        eem->port.in_ep->name, eem->port.out_ep->name);
+        return 0;
+
+fail:
+        if (f->descriptors)
+                usb_free_descriptors(f->descriptors);
+
+        /* we might as well release our claims on endpoints */
+        if (eem->port.out)
+                eem->port.out_ep->driver_data = NULL;
+        if (eem->port.in)
+                eem->port.in_ep->driver_data = NULL;
+
+        ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
+
+        return status;
+}
+
+static void
+eem_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct f_eem    *eem = func_to_eem(f);
+
+        DBG(c->cdev, "eem unbind\n");
+
+        if (gadget_is_dualspeed(c->cdev->gadget))
+                usb_free_descriptors(f->hs_descriptors);
+        usb_free_descriptors(f->descriptors);
+        kfree(eem);
+}
+
+static void eem_cmd_complete(struct usb_ep *ep, struct usb_request *req)
+{
+}
+
+/*
+ * Add the EEM header and ethernet checksum.
+ * We currently do not attempt to put multiple ethernet frames
+ * into a single USB transfer
+ */
+static struct sk_buff *eem_wrap(struct gether *port, struct sk_buff *skb)
+{
+        struct sk_buff  *skb2 = NULL;
+        struct usb_ep   *in = port->in_ep;
+        int             padlen = 0;
+        u16             len = skb->len;
+
+        if (!skb_cloned(skb)) {
+                int headroom = skb_headroom(skb);
+                int tailroom = skb_tailroom(skb);
+
+                /* When (len + EEM_HLEN + ETH_FCS_LEN) % in->maxpacket) is 0,
+                 * stick two bytes of zero-length EEM packet on the end.
+                 */
+                if (((len + EEM_HLEN + ETH_FCS_LEN) % in->maxpacket) == 0)
+                        padlen += 2;
+
+                if ((tailroom >= (ETH_FCS_LEN + padlen)) &&
+                                (headroom >= EEM_HLEN))
+                        goto done;
+        }
+
+        skb2 = skb_copy_expand(skb, EEM_HLEN, ETH_FCS_LEN + padlen, GFP_ATOMIC);
+        dev_kfree_skb_any(skb);
+        skb = skb2;
+        if (!skb)
+                return skb;
+
+done:
+        /* use the "no CRC" option */
+        put_unaligned_be32(0xdeadbeef, skb_put(skb, 4));
+
+        /* EEM packet header format:
+         * b0..13:      length of ethernet frame
+         * b14:         bmCRC (0 == sentinel CRC)
+         * b15:         bmType (0 == data)
+         */
+        len = skb->len;
+        put_unaligned_le16((len & 0x3FFF) | BIT(14), skb_push(skb, 2));
+
+        /* add a zero-length EEM packet, if needed */
+        if (padlen)
+                put_unaligned_le16(0, skb_put(skb, 2));
+
+        return skb;
+}
+
+/*
+ * Remove the EEM header.  Note that there can be many EEM packets in a single
+ * USB transfer, so we need to break them out and handle them independently.
+ */
+static int eem_unwrap(struct gether *port,
+                        struct sk_buff *skb,
+                        struct sk_buff_head *list)
+{
+        struct usb_composite_dev        *cdev = port->func.config->cdev;
+        int                             status = 0;
+
+        do {
+                struct sk_buff  *skb2;
+                u16             header;
+                u16             len = 0;
+
+                if (skb->len < EEM_HLEN) {
+                        status = -EINVAL;
+                        DBG(cdev, "invalid EEM header\n");
+                        goto error;
+                }
+
+                /* remove the EEM header */
+                header = get_unaligned_le16(skb->data);
+                skb_pull(skb, EEM_HLEN);
+
+                /* EEM packet header format:
+                 * b0..14:      EEM type dependent (data or command)
+                 * b15:         bmType (0 == data, 1 == command)
+                 */
+                if (header & BIT(15)) {
+                        struct usb_request      *req = cdev->req;
+                        u16                     bmEEMCmd;
+
+                        /* EEM command packet format:
+                         * b0..10:      bmEEMCmdParam
+                         * b11..13:     bmEEMCmd
+                         * b14:         reserved (must be zero)
+                         * b15:         bmType (1 == command)
+                         */
+                        if (header & BIT(14))
+                                continue;
+
+                        bmEEMCmd = (header >> 11) & 0x7;
+                        switch (bmEEMCmd) {
+                        case 0: /* echo */
+                                len = header & 0x7FF;
+                                if (skb->len < len) {
+                                        status = -EOVERFLOW;
+                                        goto error;
+                                }
+
+                                skb2 = skb_clone(skb, GFP_ATOMIC);
+                                if (unlikely(!skb2)) {
+                                        DBG(cdev, "EEM echo response error\n");
+                                        goto next;
+                                }
+                                skb_trim(skb2, len);
+                                put_unaligned_le16(BIT(15) | BIT(11) | len,
+                                                        skb_push(skb2, 2));
+                                skb_copy_bits(skb, 0, req->buf, skb->len);
+                                req->length = skb->len;
+                                req->complete = eem_cmd_complete;
+                                req->zero = 1;
+                                if (usb_ep_queue(port->in_ep, req, GFP_ATOMIC))
+                                        DBG(cdev, "echo response queue fail\n");
+                                break;
+
+                        case 1:  /* echo response */
+                        case 2:  /* suspend hint */
+                        case 3:  /* response hint */
+                        case 4:  /* response complete hint */
+                        case 5:  /* tickle */
+                        default: /* reserved */
+                                continue;
+                        }
+                } else {
+                        u32             crc, crc2;
+                        struct sk_buff  *skb3;
+
+                        /* check for zero-length EEM packet */
+                        if (header == 0)
+                                continue;
+
+                        /* EEM data packet format:
+                         * b0..13:      length of ethernet frame
+                         * b14:         bmCRC (0 == sentinel, 1 == calculated)
+                         * b15:         bmType (0 == data)
+                         */
+                        len = header & 0x3FFF;
+                        if ((skb->len < len)
+                                        || (len < (ETH_HLEN + ETH_FCS_LEN))) {
+                                status = -EINVAL;
+                                goto error;
+                        }
+
+                        /* validate CRC */
+                        crc = get_unaligned_le32(skb->data + len - ETH_FCS_LEN);
+                        if (header & BIT(14)) {
+                                crc = get_unaligned_le32(skb->data + len
+                                                        - ETH_FCS_LEN);
+                                crc2 = ~crc32_le(~0,
+                                                skb->data,
+                                                skb->len - ETH_FCS_LEN);
+                        } else {
+                                crc = get_unaligned_be32(skb->data + len
+                                                        - ETH_FCS_LEN);
+                                crc2 = 0xdeadbeef;
+                        }
+                        if (crc != crc2) {
+                                DBG(cdev, "invalid EEM CRC\n");
+                                goto next;
+                        }
+
+                        skb2 = skb_clone(skb, GFP_ATOMIC);
+                        if (unlikely(!skb2)) {
+                                DBG(cdev, "unable to unframe EEM packet\n");
+                                continue;
+                        }
+                        skb_trim(skb2, len - ETH_FCS_LEN);
+
+                        skb3 = skb_copy_expand(skb2,
+                                                NET_IP_ALIGN,
+                                                0,
+                                                GFP_ATOMIC);
+                        if (unlikely(!skb3)) {
+                                DBG(cdev, "unable to realign EEM packet\n");
+                                dev_kfree_skb_any(skb2);
+                                continue;
+                        }
+                        dev_kfree_skb_any(skb2);
+                        skb_queue_tail(list, skb3);
+                }
+next:
+                skb_pull(skb, len);
+        } while (skb->len);
+
+error:
+        dev_kfree_skb_any(skb);
+        return status;
+}
+
+/**
+ * eem_bind_config - add CDC Ethernet (EEM) network link to a configuration
+ * @c: the configuration to support the network link
+ * Context: single threaded during gadget setup
+ *
+ * Returns zero on success, else negative errno.
+ *
+ * Caller must have called @gether_setup().  Caller is also responsible
+ * for calling @gether_cleanup() before module unload.
+ */
+int __init eem_bind_config(struct usb_configuration *c)
+{
+        struct f_eem    *eem;
+        int             status;
+
+        /* maybe allocate device-global string IDs */
+        if (eem_string_defs[0].id == 0) {
+
+                /* control interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                eem_string_defs[0].id = status;
+                eem_intf.iInterface = status;
+        }
+
+        /* allocate and initialize one new instance */
+        eem = kzalloc(sizeof *eem, GFP_KERNEL);
+        if (!eem)
+                return -ENOMEM;
+
+        eem->port.cdc_filter = DEFAULT_FILTER;
+
+        eem->port.func.name = "cdc_eem";
+        eem->port.func.strings = eem_strings;
+        /* descriptors are per-instance copies */
+        eem->port.func.bind = eem_bind;
+        eem->port.func.unbind = eem_unbind;
+        eem->port.func.set_alt = eem_set_alt;
+        eem->port.func.setup = eem_setup;
+        eem->port.func.disable = eem_disable;
+        eem->port.wrap = eem_wrap;
+        eem->port.unwrap = eem_unwrap;
+        eem->port.header_len = EEM_HLEN;
+
+        status = usb_add_function(c, &eem->port.func);
+        if (status)
+                kfree(eem);
+        return status;
+}
+
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index 424a37c5773f..c9966cc07d3a 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -286,12 +286,17 @@ static struct usb_gadget_strings *rndis_strings[] = {
 
 /*-------------------------------------------------------------------------*/
 
-static struct sk_buff *rndis_add_header(struct sk_buff *skb)
+static struct sk_buff *rndis_add_header(struct gether *port,
+                                        struct sk_buff *skb)
 {
-        skb = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type));
-        if (skb)
-                rndis_add_hdr(skb);
-        return skb;
+        struct sk_buff *skb2;
+
+        skb2 = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type));
+        if (skb2)
+                rndis_add_hdr(skb2);
+
+        dev_kfree_skb_any(skb);
+        return skb2;
 }
 
 static void rndis_response_available(void *_rndis)
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index d701bf4698d2..7881f12413c4 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -2751,6 +2751,10 @@ static int __devexit qe_udc_remove(struct of_device *ofdev)
 /*-------------------------------------------------------------------------*/
 static struct of_device_id __devinitdata qe_udc_match[] = {
         {
+                .compatible = "fsl,mpc8323-qe-usb",
+                .data = (void *)PORT_QE,
+        },
+        {
                 .compatible = "fsl,mpc8360-qe-usb",
                 .data = (void *)PORT_QE,
         },
diff --git a/drivers/usb/gadget/gmidi.c b/drivers/usb/gadget/gmidi.c
index b9312dc6e041..d0b1e836f0e0 100644
--- a/drivers/usb/gadget/gmidi.c
+++ b/drivers/usb/gadget/gmidi.c
@@ -191,7 +191,7 @@ module_param(qlen, uint, S_IRUGO);
 #define GMIDI_MS_INTERFACE      1
 #define GMIDI_NUM_INTERFACES    2
 
-DECLARE_USB_AC_HEADER_DESCRIPTOR(1);
+DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
 DECLARE_USB_MIDI_OUT_JACK_DESCRIPTOR(1);
 DECLARE_USB_MS_ENDPOINT_DESCRIPTOR(1);
 
@@ -237,12 +237,12 @@ static const struct usb_interface_descriptor ac_interface_desc = {
 };
 
 /* B.3.2  Class-Specific AC Interface Descriptor */
-static const struct usb_ac_header_descriptor_1 ac_header_desc = {
-        .bLength =              USB_DT_AC_HEADER_SIZE(1),
+static const struct uac_ac_header_descriptor_1 ac_header_desc = {
+        .bLength =              UAC_DT_AC_HEADER_SIZE(1),
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubtype =   USB_MS_HEADER,
         .bcdADC =               cpu_to_le16(0x0100),
-        .wTotalLength =         cpu_to_le16(USB_DT_AC_HEADER_SIZE(1)),
+        .wTotalLength =         cpu_to_le16(UAC_DT_AC_HEADER_SIZE(1)),
         .bInCollection =        1,
         .baInterfaceNr = {
                 [0] =           GMIDI_MS_INTERFACE,
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index ed21e263f832..e6fedbd5a654 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -56,6 +56,7 @@
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/otg.h>
 
 /*
  * This driver is PXA25x only.  Grab the right register definitions.
@@ -1008,15 +1009,27 @@ static int pxa25x_udc_pullup(struct usb_gadget *_gadget, int is_active)
         return 0;
 }
 
+/* boards may consume current from VBUS, up to 100-500mA based on config.
+ * the 500uA suspend ceiling means that exclusively vbus-powered PXA designs
+ * violate USB specs.
+ */
+static int pxa25x_udc_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
+{
+        struct pxa25x_udc       *udc;
+
+        udc = container_of(_gadget, struct pxa25x_udc, gadget);
+
+        if (udc->transceiver)
+                return otg_set_power(udc->transceiver, mA);
+        return -EOPNOTSUPP;
+}
+
 static const struct usb_gadget_ops pxa25x_udc_ops = {
         .get_frame      = pxa25x_udc_get_frame,
         .wakeup         = pxa25x_udc_wakeup,
         .vbus_session   = pxa25x_udc_vbus_session,
         .pullup         = pxa25x_udc_pullup,
-
-        // .vbus_draw ... boards may consume current from VBUS, up to
-        // 100-500mA based on config.  the 500uA suspend ceiling means
-        // that exclusively vbus-powered PXA designs violate USB specs.
+        .vbus_draw      = pxa25x_udc_vbus_draw,
 };
 
 /*-------------------------------------------------------------------------*/
@@ -1303,9 +1316,23 @@ fail:
          * for set_configuration as well as eventual disconnect.
          */
         DMSG("registered gadget driver '%s'\n", driver->driver.name);
+
+        /* connect to bus through transceiver */
+        if (dev->transceiver) {
+                retval = otg_set_peripheral(dev->transceiver, &dev->gadget);
+                if (retval) {
+                        DMSG("can't bind to transceiver\n");
+                        if (driver->unbind)
+                                driver->unbind(&dev->gadget);
+                        goto bind_fail;
+                }
+        }
+
         pullup(dev);
         dump_state(dev);
         return 0;
+bind_fail:
+        return retval;
 }
 EXPORT_SYMBOL(usb_gadget_register_driver);
 
@@ -1351,6 +1378,9 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         stop_activity(dev, driver);
         local_irq_enable();
 
+        if (dev->transceiver)
+                (void) otg_set_peripheral(dev->transceiver, NULL);
+
         driver->unbind(&dev->gadget);
         dev->gadget.dev.driver = NULL;
         dev->driver = NULL;
@@ -2162,6 +2192,8 @@ static int __init pxa25x_udc_probe(struct platform_device *pdev)
         dev->dev = &pdev->dev;
         dev->mach = pdev->dev.platform_data;
 
+        dev->transceiver = otg_get_transceiver();
+
         if (gpio_is_valid(dev->mach->gpio_vbus)) {
                 if ((retval = gpio_request(dev->mach->gpio_vbus,
                                 "pxa25x_udc GPIO VBUS"))) {
@@ -2264,6 +2296,10 @@ lubbock_fail0:
         if (gpio_is_valid(dev->mach->gpio_vbus))
                 gpio_free(dev->mach->gpio_vbus);
  err_gpio_vbus:
+        if (dev->transceiver) {
+                otg_put_transceiver(dev->transceiver);
+                dev->transceiver = NULL;
+        }
         clk_put(dev->clk);
  err_clk:
         return retval;
@@ -2305,6 +2341,11 @@ static int __exit pxa25x_udc_remove(struct platform_device *pdev)
 
         clk_put(dev->clk);
 
+        if (dev->transceiver) {
+                otg_put_transceiver(dev->transceiver);
+                dev->transceiver = NULL;
+        }
+
         platform_set_drvdata(pdev, NULL);
         the_controller = NULL;
         return 0;
diff --git a/drivers/usb/gadget/pxa25x_udc.h b/drivers/usb/gadget/pxa25x_udc.h
index 1d51aa21e6eb..f572c5617462 100644
--- a/drivers/usb/gadget/pxa25x_udc.h
+++ b/drivers/usb/gadget/pxa25x_udc.h
@@ -128,6 +128,7 @@ struct pxa25x_udc {
         struct device                           *dev;
         struct clk                              *clk;
         struct pxa2xx_udc_mach_info             *mach;
+        struct otg_transceiver                  *transceiver;
         u64                                     dma_mask;
         struct pxa25x_ep                        ep [PXA_UDC_NUM_ENDPOINTS];
 
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index ca41b0b5afb3..48267bc0b2e0 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -1022,22 +1022,29 @@ static rndis_resp_t *rndis_add_response (int configNr, u32 length)
         return r;
 }
 
-int rndis_rm_hdr(struct sk_buff *skb)
+int rndis_rm_hdr(struct gether *port,
+                        struct sk_buff *skb,
+                        struct sk_buff_head *list)
 {
         /* tmp points to a struct rndis_packet_msg_type */
         __le32          *tmp = (void *) skb->data;
 
         /* MessageType, MessageLength */
         if (cpu_to_le32(REMOTE_NDIS_PACKET_MSG)
-                        != get_unaligned(tmp++))
+                        != get_unaligned(tmp++)) {
+                dev_kfree_skb_any(skb);
                 return -EINVAL;
+        }
         tmp++;
 
         /* DataOffset, DataLength */
-        if (!skb_pull(skb, get_unaligned_le32(tmp++) + 8))
+        if (!skb_pull(skb, get_unaligned_le32(tmp++) + 8)) {
+                dev_kfree_skb_any(skb);
                 return -EOVERFLOW;
+        }
         skb_trim(skb, get_unaligned_le32(tmp++));
 
+        skb_queue_tail(list, skb);
         return 0;
 }
 
diff --git a/drivers/usb/gadget/rndis.h b/drivers/usb/gadget/rndis.h
index aac61dfe0f03..c236aaa9dcd1 100644
--- a/drivers/usb/gadget/rndis.h
+++ b/drivers/usb/gadget/rndis.h
@@ -251,7 +251,8 @@ int  rndis_set_param_vendor (u8 configNr, u32 vendorID,
                             const char *vendorDescr);
 int  rndis_set_param_medium (u8 configNr, u32 medium, u32 speed);
 void rndis_add_hdr (struct sk_buff *skb);
-int rndis_rm_hdr (struct sk_buff *skb);
+int rndis_rm_hdr(struct gether *port, struct sk_buff *skb,
+                        struct sk_buff_head *list);
 u8   *rndis_get_next_response (int configNr, u32 *length);
 void rndis_free_response (int configNr, u8 *buf);
 
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c
index 50c71aae2cc2..4b5dbd0127f5 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/gadget/s3c-hsotg.c
@@ -2392,7 +2392,7 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
                 grstctl = readl(hsotg->regs + S3C_GRSTCTL);
         } 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;
         }
@@ -2514,8 +2514,8 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
          * DMA mode we may need this. */
         writel(S3C_DOEPMSK_SetupMsk | S3C_DOEPMSK_AHBErrMsk |
                S3C_DOEPMSK_EPDisbldMsk |
-               using_dma(hsotg) ? (S3C_DIEPMSK_XferComplMsk |
-                                   S3C_DIEPMSK_TimeOUTMsk) : 0,
+               (using_dma(hsotg) ? (S3C_DIEPMSK_XferComplMsk |
+                                   S3C_DIEPMSK_TimeOUTMsk) : 0),
                hsotg->regs + S3C_DOEPMSK);
 
         writel(0, hsotg->regs + S3C_DAINTMSK);
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index a9b452fe6221..d5f4c1d45c97 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -1703,8 +1703,7 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         dprintk(DEBUG_NORMAL,"usb_gadget_register_driver() '%s'\n",
                 driver->driver.name);
 
-        if (driver->disconnect)
-                driver->disconnect(&udc->gadget);
+        driver->unbind(&udc->gadget);
 
         device_del(&udc->gadget.dev);
         udc->driver = NULL;
diff --git a/drivers/usb/gadget/u_audio.c b/drivers/usb/gadget/u_audio.c
index 0f3d22fc030e..b5200d551458 100644
--- a/drivers/usb/gadget/u_audio.c
+++ b/drivers/usb/gadget/u_audio.c
@@ -253,11 +253,13 @@ static int gaudio_open_snd_dev(struct gaudio *card)
         snd->filp = filp_open(fn_cap, O_RDONLY, 0);
         if (IS_ERR(snd->filp)) {
                 ERROR(card, "No such PCM capture device: %s\n", fn_cap);
-                snd->filp = NULL;
+                snd->substream = NULL;
+                snd->card = NULL;
+        } else {
+                pcm_file = snd->filp->private_data;
+                snd->substream = pcm_file->substream;
+                snd->card = card;
         }
-        pcm_file = snd->filp->private_data;
-        snd->substream = pcm_file->substream;
-        snd->card = card;
 
         return 0;
 }
diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
index c66521953917..f8751ff863cd 100644
--- a/drivers/usb/gadget/u_ether.c
+++ b/drivers/usb/gadget/u_ether.c
@@ -37,8 +37,9 @@
  * one (!) network link through the USB gadget stack, normally "usb0".
  *
  * The control and data models are handled by the function driver which
- * connects to this code; such as CDC Ethernet, "CDC Subset", or RNDIS.
- * That includes all descriptor and endpoint management.
+ * connects to this code; such as CDC Ethernet (ECM or EEM),
+ * "CDC Subset", or RNDIS.  That includes all descriptor and endpoint
+ * management.
  *
  * Link level addressing is handled by this component using module
  * parameters; if no such parameters are provided, random link level
@@ -68,9 +69,13 @@ struct eth_dev {
         struct list_head        tx_reqs, rx_reqs;
         atomic_t                tx_qlen;
 
+        struct sk_buff_head     rx_frames;
+
         unsigned                header_len;
-        struct sk_buff          *(*wrap)(struct sk_buff *skb);
-        int                     (*unwrap)(struct sk_buff *skb);
+        struct sk_buff          *(*wrap)(struct gether *, struct sk_buff *skb);
+        int                     (*unwrap)(struct gether *,
+                                                struct sk_buff *skb,
+                                                struct sk_buff_head *list);
 
         struct work_struct      work;
 
@@ -269,7 +274,7 @@ enomem:
 
 static void rx_complete(struct usb_ep *ep, struct usb_request *req)
 {
-        struct sk_buff  *skb = req->context;
+        struct sk_buff  *skb = req->context, *skb2;
         struct eth_dev  *dev = ep->driver_data;
         int             status = req->status;
 
@@ -278,26 +283,47 @@ static void rx_complete(struct usb_ep *ep, struct usb_request *req)
         /* normal completion */
         case 0:
                 skb_put(skb, req->actual);
-                if (dev->unwrap)
-                        status = dev->unwrap(skb);
-                if (status < 0
-                                || ETH_HLEN > skb->len
-                                || skb->len > ETH_FRAME_LEN) {
-                        dev->net->stats.rx_errors++;
-                        dev->net->stats.rx_length_errors++;
-                        DBG(dev, "rx length %d\n", skb->len);
-                        break;
-                }
 
-                skb->protocol = eth_type_trans(skb, dev->net);
-                dev->net->stats.rx_packets++;
-                dev->net->stats.rx_bytes += skb->len;
+                if (dev->unwrap) {
+                        unsigned long   flags;
 
-                /* no buffer copies needed, unless hardware can't
-                 * use skb buffers.
-                 */
-                status = netif_rx(skb);
+                        spin_lock_irqsave(&dev->lock, flags);
+                        if (dev->port_usb) {
+                                status = dev->unwrap(dev->port_usb,
+                                                        skb,
+                                                        &dev->rx_frames);
+                        } else {
+                                dev_kfree_skb_any(skb);
+                                status = -ENOTCONN;
+                        }
+                        spin_unlock_irqrestore(&dev->lock, flags);
+                } else {
+                        skb_queue_tail(&dev->rx_frames, skb);
+                }
                 skb = NULL;
+
+                skb2 = skb_dequeue(&dev->rx_frames);
+                while (skb2) {
+                        if (status < 0
+                                        || ETH_HLEN > skb2->len
+                                        || skb2->len > ETH_FRAME_LEN) {
+                                dev->net->stats.rx_errors++;
+                                dev->net->stats.rx_length_errors++;
+                                DBG(dev, "rx length %d\n", skb2->len);
+                                dev_kfree_skb_any(skb2);
+                                goto next_frame;
+                        }
+                        skb2->protocol = eth_type_trans(skb2, dev->net);
+                        dev->net->stats.rx_packets++;
+                        dev->net->stats.rx_bytes += skb2->len;
+
+                        /* no buffer copies needed, unless hardware can't
+                         * use skb buffers.
+                         */
+                        status = netif_rx(skb2);
+next_frame:
+                        skb2 = skb_dequeue(&dev->rx_frames);
+                }
                 break;
 
         /* software-driven interface shutdown */
@@ -537,14 +563,15 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
          * or there's not enough space for extra headers we need
          */
         if (dev->wrap) {
-                struct sk_buff  *skb_new;
+                unsigned long   flags;
 
-                skb_new = dev->wrap(skb);
-                if (!skb_new)
+                spin_lock_irqsave(&dev->lock, flags);
+                if (dev->port_usb)
+                        skb = dev->wrap(dev->port_usb, skb);
+                spin_unlock_irqrestore(&dev->lock, flags);
+                if (!skb)
                         goto drop;
 
-                dev_kfree_skb_any(skb);
-                skb = skb_new;
                 length = skb->len;
         }
         req->buf = skb->data;
@@ -578,9 +605,9 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
         }
 
         if (retval) {
+                dev_kfree_skb_any(skb);
 drop:
                 dev->net->stats.tx_dropped++;
-                dev_kfree_skb_any(skb);
                 spin_lock_irqsave(&dev->req_lock, flags);
                 if (list_empty(&dev->tx_reqs))
                         netif_start_queue(net);
@@ -753,6 +780,8 @@ int __init gether_setup(struct usb_gadget *g, u8 ethaddr[ETH_ALEN])
         INIT_LIST_HEAD(&dev->tx_reqs);
         INIT_LIST_HEAD(&dev->rx_reqs);
 
+        skb_queue_head_init(&dev->rx_frames);
+
         /* network device setup */
         dev->net = net;
         strcpy(net->name, "usb%d");
diff --git a/drivers/usb/gadget/u_ether.h b/drivers/usb/gadget/u_ether.h
index 0d1f7ae3b071..91b39ffdf6ea 100644
--- a/drivers/usb/gadget/u_ether.h
+++ b/drivers/usb/gadget/u_ether.h
@@ -60,12 +60,13 @@ struct gether {
 
         u16                             cdc_filter;
 
-        /* hooks for added framing, as needed for RNDIS and EEM.
-         * we currently don't support multiple frames per SKB.
-         */
+        /* hooks for added framing, as needed for RNDIS and EEM. */
         u32                             header_len;
-        struct sk_buff                  *(*wrap)(struct sk_buff *skb);
-        int                             (*unwrap)(struct sk_buff *skb);
+        struct sk_buff                  *(*wrap)(struct gether *port,
+                                                struct sk_buff *skb);
+        int                             (*unwrap)(struct gether *port,
+                                                struct sk_buff *skb,
+                                                struct sk_buff_head *list);
 
         /* called on network open/close */
         void                            (*open)(struct gether *);
@@ -109,6 +110,7 @@ static inline bool can_support_ecm(struct usb_gadget *gadget)
 /* each configuration may bind one instance of an ethernet link */
 int geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 int ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
+int eem_bind_config(struct usb_configuration *c);
 
 #ifdef CONFIG_USB_ETH_RNDIS
 
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
index fc6e709f45b1..adf8260c3a6a 100644
--- a/drivers/usb/gadget/u_serial.c
+++ b/drivers/usb/gadget/u_serial.c
@@ -1114,7 +1114,6 @@ int __init gserial_setup(struct usb_gadget *g, unsigned count)
         /* export the driver ... */
         status = tty_register_driver(gs_tty_driver);
         if (status) {
-                put_tty_driver(gs_tty_driver);
                 pr_err("%s: cannot register, err %d\n",
                                 __func__, status);
                 goto fail;
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index f21ca7d27a43..9b43b226817f 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -113,6 +113,12 @@ config USB_EHCI_HCD_PPC_OF
           Enables support for the USB controller present on the PowerPC
           OpenFirmware platform bus.
 
+config USB_W90X900_EHCI
+        bool "W90X900(W90P910) EHCI support"
+        depends on USB_EHCI_HCD && ARCH_W90X900
+        ---help---
+                Enables support for the W90X900 USB controller
+
 config USB_OXU210HP_HCD
         tristate "OXU210HP HCD support"
         depends on USB
@@ -153,6 +159,18 @@ config USB_ISP1760_HCD
           To compile this driver as a module, choose M here: the
           module will be called isp1760.
 
+config USB_ISP1362_HCD
+        tristate "ISP1362 HCD support"
+        depends on USB
+        default N
+        ---help---
+          Supports the Philips ISP1362 chip as a host controller
+
+          This driver does not support isochronous transfers.
+
+          To compile this driver as a module, choose M here: the
+          module will be called isp1362-hcd.
+
 config USB_OHCI_HCD
         tristate "OHCI HCD support"
         depends on USB && USB_ARCH_HAS_OHCI
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 289d748bb414..f58b2494c44a 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_PCI)		+= pci-quirks.o
 obj-$(CONFIG_USB_EHCI_HCD)      += ehci-hcd.o
 obj-$(CONFIG_USB_OXU210HP_HCD)  += oxu210hp-hcd.o
 obj-$(CONFIG_USB_ISP116X_HCD)   += isp116x-hcd.o
+obj-$(CONFIG_USB_ISP1362_HCD)   += isp1362-hcd.o
 obj-$(CONFIG_USB_OHCI_HCD)      += ohci-hcd.o
 obj-$(CONFIG_USB_UHCI_HCD)      += uhci-hcd.o
 obj-$(CONFIG_USB_FHCI_HCD)      += fhci.o
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
new file mode 100644
index 000000000000..87c1b7c34c0e
--- /dev/null
+++ b/drivers/usb/host/ehci-atmel.c
@@ -0,0 +1,230 @@
+/*
+ * Driver for EHCI UHP on Atmel chips
+ *
+ *  Copyright (C) 2009 Atmel Corporation,
+ *                     Nicolas Ferre <nicolas.ferre@atmel.com>
+ *
+ *  Based on various ehci-*.c drivers
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive for
+ * more details.
+ */
+
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+
+/* interface and function clocks */
+static struct clk *iclk, *fclk;
+static int clocked;
+
+/*-------------------------------------------------------------------------*/
+
+static void atmel_start_clock(void)
+{
+        clk_enable(iclk);
+        clk_enable(fclk);
+        clocked = 1;
+}
+
+static void atmel_stop_clock(void)
+{
+        clk_disable(fclk);
+        clk_disable(iclk);
+        clocked = 0;
+}
+
+static void atmel_start_ehci(struct platform_device *pdev)
+{
+        dev_dbg(&pdev->dev, "start\n");
+        atmel_start_clock();
+}
+
+static void atmel_stop_ehci(struct platform_device *pdev)
+{
+        dev_dbg(&pdev->dev, "stop\n");
+        atmel_stop_clock();
+}
+
+/*-------------------------------------------------------------------------*/
+
+static int ehci_atmel_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval = 0;
+
+        /* registers start at offset 0x0 */
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs +
+                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        /* data structure init */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci->sbrn = 0x20;
+
+        ehci_reset(ehci);
+        ehci_port_power(ehci, 0);
+
+        return retval;
+}
+
+static const struct hc_driver ehci_atmel_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Atmel EHCI UHP HS",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /* generic hardware linkage */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /* basic lifecycle operations */
+        .reset                  = ehci_atmel_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,
+
+        /* scheduling support */
+        .get_frame_number       = ehci_get_frame,
+
+        /* root hub support */
+        .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,
+};
+
+static int __init ehci_atmel_drv_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        const struct hc_driver *driver = &ehci_atmel_hc_driver;
+        struct resource *res;
+        int irq;
+        int retval;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_debug("Initializing Atmel-SoC USB Host Controller\n");
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq <= 0) {
+                dev_err(&pdev->dev,
+                        "Found HC with no IRQ. Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                retval = -ENODEV;
+                goto fail_create_hcd;
+        }
+
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto fail_create_hcd;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev,
+                        "Found HC with no register addr. Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                retval = -ENODEV;
+                goto fail_request_resource;
+        }
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = res->end - res->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                                driver->description)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                retval = -EBUSY;
+                goto fail_request_resource;
+        }
+
+        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        if (hcd->regs == NULL) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                retval = -EFAULT;
+                goto fail_ioremap;
+        }
+
+        iclk = clk_get(&pdev->dev, "ehci_clk");
+        if (IS_ERR(iclk)) {
+                dev_err(&pdev->dev, "Error getting interface clock\n");
+                retval = -ENOENT;
+                goto fail_get_iclk;
+        }
+        fclk = clk_get(&pdev->dev, "uhpck");
+        if (IS_ERR(fclk)) {
+                dev_err(&pdev->dev, "Error getting function clock\n");
+                retval = -ENOENT;
+                goto fail_get_fclk;
+        }
+
+        atmel_start_ehci(pdev);
+
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        if (retval)
+                goto fail_add_hcd;
+
+        return retval;
+
+fail_add_hcd:
+        atmel_stop_ehci(pdev);
+        clk_put(fclk);
+fail_get_fclk:
+        clk_put(iclk);
+fail_get_iclk:
+        iounmap(hcd->regs);
+fail_ioremap:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+fail_request_resource:
+        usb_put_hcd(hcd);
+fail_create_hcd:
+        dev_err(&pdev->dev, "init %s fail, %d\n",
+                dev_name(&pdev->dev), retval);
+
+        return retval;
+}
+
+static int __exit ehci_atmel_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        ehci_shutdown(hcd);
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        atmel_stop_ehci(pdev);
+        clk_put(fclk);
+        clk_put(iclk);
+        fclk = iclk = NULL;
+
+        return 0;
+}
+
+static struct platform_driver ehci_atmel_driver = {
+        .probe          = ehci_atmel_drv_probe,
+        .remove         = __exit_p(ehci_atmel_drv_remove),
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver.name    = "atmel-ehci",
+};
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index 59d208d94d4e..ed77be76d6bb 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -199,10 +199,9 @@ static int ehci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int ehci_hcd_au1xxx_drv_suspend(struct platform_device *pdev,
-                                        pm_message_t message)
+static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         unsigned long flags;
         int rc;
@@ -229,12 +228,6 @@ static int ehci_hcd_au1xxx_drv_suspend(struct platform_device *pdev,
         ehci_writel(ehci, 0, &ehci->regs->intr_enable);
         (void)ehci_readl(ehci, &ehci->regs->intr_enable);
 
-        /* make sure snapshot being resumed re-enumerates everything */
-        if (message.event == PM_EVENT_PRETHAW) {
-                ehci_halt(ehci);
-                ehci_reset(ehci);
-        }
-
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
         au1xxx_stop_ehc();
@@ -248,10 +241,9 @@ bail:
         return rc;
 }
 
-
-static int ehci_hcd_au1xxx_drv_resume(struct platform_device *pdev)
+static int ehci_hcd_au1xxx_drv_resume(struct device *dev)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 
         au1xxx_start_ehc();
@@ -305,20 +297,25 @@ static int ehci_hcd_au1xxx_drv_resume(struct platform_device *pdev)
         return 0;
 }
 
+static struct dev_pm_ops au1xxx_ehci_pmops = {
+        .suspend        = ehci_hcd_au1xxx_drv_suspend,
+        .resume         = ehci_hcd_au1xxx_drv_resume,
+};
+
+#define AU1XXX_EHCI_PMOPS &au1xxx_ehci_pmops
+
 #else
-#define ehci_hcd_au1xxx_drv_suspend NULL
-#define ehci_hcd_au1xxx_drv_resume NULL
+#define AU1XXX_EHCI_PMOPS NULL
 #endif
 
 static struct platform_driver ehci_hcd_au1xxx_driver = {
         .probe          = ehci_hcd_au1xxx_drv_probe,
         .remove         = ehci_hcd_au1xxx_drv_remove,
         .shutdown       = usb_hcd_platform_shutdown,
-        .suspend        = ehci_hcd_au1xxx_drv_suspend,
-        .resume         = ehci_hcd_au1xxx_drv_resume,
         .driver = {
                 .name   = "au1xxx-ehci",
                 .owner  = THIS_MODULE,
+                .pm     = AU1XXX_EHCI_PMOPS,
         }
 };
 
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 7f4ace73d44a..874d2000bf92 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -134,10 +134,11 @@ dbg_qtd (const char *label, struct ehci_hcd *ehci, struct ehci_qtd *qtd)
 static void __maybe_unused
 dbg_qh (const char *label, struct ehci_hcd *ehci, struct ehci_qh *qh)
 {
+        struct ehci_qh_hw *hw = qh->hw;
+
         ehci_dbg (ehci, "%s qh %p n%08x info %x %x qtd %x\n", label,
-                qh, qh->hw_next, qh->hw_info1, qh->hw_info2,
-                qh->hw_current);
-        dbg_qtd ("overlay", ehci, (struct ehci_qtd *) &qh->hw_qtd_next);
+                qh, hw->hw_next, hw->hw_info1, hw->hw_info2, hw->hw_current);
+        dbg_qtd("overlay", ehci, (struct ehci_qtd *) &hw->hw_qtd_next);
 }
 
 static void __maybe_unused
@@ -400,31 +401,32 @@ static void qh_lines (
         char                    *next = *nextp;
         char                    mark;
         __le32                  list_end = EHCI_LIST_END(ehci);
+        struct ehci_qh_hw       *hw = qh->hw;
 
-        if (qh->hw_qtd_next == list_end)        /* NEC does this */
+        if (hw->hw_qtd_next == list_end)        /* NEC does this */
                 mark = '@';
         else
-                mark = token_mark(ehci, qh->hw_token);
+                mark = token_mark(ehci, hw->hw_token);
         if (mark == '/') {      /* qh_alt_next controls qh advance? */
-                if ((qh->hw_alt_next & QTD_MASK(ehci))
-                                == ehci->async->hw_alt_next)
+                if ((hw->hw_alt_next & QTD_MASK(ehci))
+                                == ehci->async->hw->hw_alt_next)
                         mark = '#';     /* blocked */
-                else if (qh->hw_alt_next == list_end)
+                else if (hw->hw_alt_next == list_end)
                         mark = '.';     /* use hw_qtd_next */
                 /* else alt_next points to some other qtd */
         }
-        scratch = hc32_to_cpup(ehci, &qh->hw_info1);
-        hw_curr = (mark == '*') ? hc32_to_cpup(ehci, &qh->hw_current) : 0;
+        scratch = hc32_to_cpup(ehci, &hw->hw_info1);
+        hw_curr = (mark == '*') ? hc32_to_cpup(ehci, &hw->hw_current) : 0;
         temp = scnprintf (next, size,
                         "qh/%p dev%d %cs ep%d %08x %08x (%08x%c %s nak%d)",
                         qh, scratch & 0x007f,
                         speed_char (scratch),
                         (scratch >> 8) & 0x000f,
-                        scratch, hc32_to_cpup(ehci, &qh->hw_info2),
-                        hc32_to_cpup(ehci, &qh->hw_token), mark,
-                        (cpu_to_hc32(ehci, QTD_TOGGLE) & qh->hw_token)
+                        scratch, hc32_to_cpup(ehci, &hw->hw_info2),
+                        hc32_to_cpup(ehci, &hw->hw_token), mark,
+                        (cpu_to_hc32(ehci, QTD_TOGGLE) & hw->hw_token)
                                 ? "data1" : "data0",
-                        (hc32_to_cpup(ehci, &qh->hw_alt_next) >> 1) & 0x0f);
+                        (hc32_to_cpup(ehci, &hw->hw_alt_next) >> 1) & 0x0f);
         size -= temp;
         next += temp;
 
@@ -435,10 +437,10 @@ static void qh_lines (
                 mark = ' ';
                 if (hw_curr == td->qtd_dma)
                         mark = '*';
-                else if (qh->hw_qtd_next == cpu_to_hc32(ehci, td->qtd_dma))
+                else if (hw->hw_qtd_next == cpu_to_hc32(ehci, td->qtd_dma))
                         mark = '+';
                 else if (QTD_LENGTH (scratch)) {
-                        if (td->hw_alt_next == ehci->async->hw_alt_next)
+                        if (td->hw_alt_next == ehci->async->hw->hw_alt_next)
                                 mark = '#';
                         else if (td->hw_alt_next != list_end)
                                 mark = '/';
@@ -550,12 +552,15 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
                 next += temp;
 
                 do {
+                        struct ehci_qh_hw *hw;
+
                         switch (hc32_to_cpu(ehci, tag)) {
                         case Q_TYPE_QH:
+                                hw = p.qh->hw;
                                 temp = scnprintf (next, size, " qh%d-%04x/%p",
                                                 p.qh->period,
                                                 hc32_to_cpup(ehci,
-                                                                &p.qh->hw_info2)
+                                                        &hw->hw_info2)
                                                         /* uframe masks */
                                                         & (QH_CMASK | QH_SMASK),
                                                 p.qh);
@@ -576,7 +581,7 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
                                 /* show more info the first time around */
                                 if (temp == seen_count) {
                                         u32     scratch = hc32_to_cpup(ehci,
-                                                        &p.qh->hw_info1);
+                                                        &hw->hw_info1);
                                         struct ehci_qtd *qtd;
                                         char            *type = "";
 
@@ -609,7 +614,7 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
                                 } else
                                         temp = 0;
                                 if (p.qh) {
-                                        tag = Q_NEXT_TYPE(ehci, p.qh->hw_next);
+                                        tag = Q_NEXT_TYPE(ehci, hw->hw_next);
                                         p = p.qh->qh_next;
                                 }
                                 break;
@@ -879,8 +884,7 @@ static int debug_close(struct inode *inode, struct file *file)
         struct debug_buffer *buf = file->private_data;
 
         if (buf) {
-                if (buf->output_buf)
-                        vfree(buf->output_buf);
+                vfree(buf->output_buf);
                 kfree(buf);
         }
 
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 11c627ce6022..9835e0713943 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -30,7 +30,6 @@
 #include <linux/timer.h>
 #include <linux/list.h>
 #include <linux/interrupt.h>
-#include <linux/reboot.h>
 #include <linux/usb.h>
 #include <linux/moduleparam.h>
 #include <linux/dma-mapping.h>
@@ -127,6 +126,8 @@ timer_action(struct ehci_hcd *ehci, enum ehci_timer_action action)
 
                 switch (action) {
                 case TIMER_IO_WATCHDOG:
+                        if (!ehci->need_io_watchdog)
+                                return;
                         t = EHCI_IO_JIFFIES;
                         break;
                 case TIMER_ASYNC_OFF:
@@ -239,6 +240,11 @@ static int ehci_reset (struct ehci_hcd *ehci)
         int     retval;
         u32     command = ehci_readl(ehci, &ehci->regs->command);
 
+        /* If the EHCI debug controller is active, special care must be
+         * taken before and after a host controller reset */
+        if (ehci->debug && !dbgp_reset_prep())
+                ehci->debug = NULL;
+
         command |= CMD_RESET;
         dbg_cmd (ehci, "reset", command);
         ehci_writel(ehci, command, &ehci->regs->command);
@@ -247,12 +253,21 @@ static int ehci_reset (struct ehci_hcd *ehci)
         retval = handshake (ehci, &ehci->regs->command,
                             CMD_RESET, 0, 250 * 1000);
 
+        if (ehci->has_hostpc) {
+                ehci_writel(ehci, USBMODE_EX_HC | USBMODE_EX_VBPS,
+                        (u32 __iomem *)(((u8 *)ehci->regs) + USBMODE_EX));
+                ehci_writel(ehci, TXFIFO_DEFAULT,
+                        (u32 __iomem *)(((u8 *)ehci->regs) + TXFILLTUNING));
+        }
         if (retval)
                 return retval;
 
         if (ehci_is_TDI(ehci))
                 tdi_reset (ehci);
 
+        if (ehci->debug)
+                dbgp_external_startup();
+
         return retval;
 }
 
@@ -505,9 +520,14 @@ static int ehci_init(struct usb_hcd *hcd)
         u32                     temp;
         int                     retval;
         u32                     hcc_params;
+        struct ehci_qh_hw       *hw;
 
         spin_lock_init(&ehci->lock);
 
+        /*
+         * keep io watchdog by default, those good HCDs could turn off it later
+         */
+        ehci->need_io_watchdog = 1;
         init_timer(&ehci->watchdog);
         ehci->watchdog.function = ehci_watchdog;
         ehci->watchdog.data = (unsigned long) ehci;
@@ -544,12 +564,13 @@ static int ehci_init(struct usb_hcd *hcd)
          * from automatically advancing to the next td after short reads.
          */
         ehci->async->qh_next.qh = NULL;
-        ehci->async->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
-        ehci->async->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
-        ehci->async->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
-        ehci->async->hw_qtd_next = EHCI_LIST_END(ehci);
+        hw = ehci->async->hw;
+        hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
+        hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
+        hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
+        hw->hw_qtd_next = EHCI_LIST_END(ehci);
         ehci->async->qh_state = QH_STATE_LINKED;
-        ehci->async->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
+        hw->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
 
         /* clear interrupt enables, set irq latency */
         if (log2_irq_thresh < 0 || log2_irq_thresh > 6)
@@ -850,12 +871,18 @@ static void unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
         if (!HC_IS_RUNNING(ehci_to_hcd(ehci)->state) && ehci->reclaim)
                 end_unlink_async(ehci);
 
-        /* if it's not linked then there's nothing to do */
-        if (qh->qh_state != QH_STATE_LINKED)
-                ;
+        /* If the QH isn't linked then there's nothing we can do
+         * unless we were called during a giveback, in which case
+         * qh_completions() has to deal with it.
+         */
+        if (qh->qh_state != QH_STATE_LINKED) {
+                if (qh->qh_state == QH_STATE_COMPLETING)
+                        qh->needs_rescan = 1;
+                return;
+        }
 
         /* defer till later if busy */
-        else if (ehci->reclaim) {
+        if (ehci->reclaim) {
                 struct ehci_qh          *last;
 
                 for (last = ehci->reclaim;
@@ -915,8 +942,9 @@ static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                         break;
                 switch (qh->qh_state) {
                 case QH_STATE_LINKED:
+                case QH_STATE_COMPLETING:
                         intr_deschedule (ehci, qh);
-                        /* FALL THROUGH */
+                        break;
                 case QH_STATE_IDLE:
                         qh_completions (ehci, qh);
                         break;
@@ -925,23 +953,6 @@ static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                                         qh, qh->qh_state);
                         goto done;
                 }
-
-                /* reschedule QH iff another request is queued */
-                if (!list_empty (&qh->qtd_list)
-                                && HC_IS_RUNNING (hcd->state)) {
-                        rc = qh_schedule(ehci, qh);
-
-                        /* An error here likely indicates handshake failure
-                         * or no space left in the schedule.  Neither fault
-                         * should happen often ...
-                         *
-                         * FIXME kill the now-dysfunctional queued urbs
-                         */
-                        if (rc != 0)
-                                ehci_err(ehci,
-                                        "can't reschedule qh %p, err %d",
-                                        qh, rc);
-                }
                 break;
 
         case PIPE_ISOCHRONOUS:
@@ -979,7 +990,7 @@ rescan:
         /* endpoints can be iso streams.  for now, we don't
          * accelerate iso completions ... so spin a while.
          */
-        if (qh->hw_info1 == 0) {
+        if (qh->hw->hw_info1 == 0) {
                 ehci_vdbg (ehci, "iso delay\n");
                 goto idle_timeout;
         }
@@ -988,6 +999,7 @@ rescan:
                 qh->qh_state = QH_STATE_IDLE;
         switch (qh->qh_state) {
         case QH_STATE_LINKED:
+        case QH_STATE_COMPLETING:
                 for (tmp = ehci->async->qh_next.qh;
                                 tmp && tmp != qh;
                                 tmp = tmp->qh_next.qh)
@@ -1052,18 +1064,17 @@ ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
                 usb_settoggle(qh->dev, epnum, is_out, 0);
                 if (!list_empty(&qh->qtd_list)) {
                         WARN_ONCE(1, "clear_halt for a busy endpoint\n");
-                } else if (qh->qh_state == QH_STATE_LINKED) {
+                } else if (qh->qh_state == QH_STATE_LINKED ||
+                                qh->qh_state == QH_STATE_COMPLETING) {
 
                         /* The toggle value in the QH can't be updated
                          * while the QH is active.  Unlink it now;
                          * re-linking will call qh_refresh().
                          */
-                        if (eptype == USB_ENDPOINT_XFER_BULK) {
+                        if (eptype == USB_ENDPOINT_XFER_BULK)
                                 unlink_async(ehci, qh);
-                        } else {
+                        else
                                 intr_deschedule(ehci, qh);
-                                (void) qh_schedule(ehci, qh);
-                        }
                 }
         }
         spin_unlock_irqrestore(&ehci->lock, flags);
@@ -1117,6 +1128,16 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ixp4xx_ehci_driver
 #endif
 
+#ifdef CONFIG_USB_W90X900_EHCI
+#include "ehci-w90x900.c"
+#define PLATFORM_DRIVER         ehci_hcd_w90x900_driver
+#endif
+
+#ifdef CONFIG_ARCH_AT91
+#include "ehci-atmel.c"
+#define PLATFORM_DRIVER         ehci_atmel_driver
+#endif
+
 #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
     !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER)
 #error "missing bus glue for ehci-hcd"
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index f46ad27c9a90..1b6f1c0e5cee 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -111,6 +111,7 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
         int                     port;
         int                     mask;
+        u32 __iomem             *hostpc_reg = NULL;
 
         ehci_dbg(ehci, "suspend root hub\n");
 
@@ -142,6 +143,9 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
                 u32             t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
                 u32             t2 = t1;
 
+                if (ehci->has_hostpc)
+                        hostpc_reg = (u32 __iomem *)((u8 *)ehci->regs
+                                + HOSTPC0 + 4 * (port & 0xff));
                 /* keep track of which ports we suspend */
                 if (t1 & PORT_OWNER)
                         set_bit(port, &ehci->owned_ports);
@@ -151,15 +155,37 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
                 }
 
                 /* enable remote wakeup on all ports */
-                if (hcd->self.root_hub->do_remote_wakeup)
-                        t2 |= PORT_WAKE_BITS;
-                else
+                if (hcd->self.root_hub->do_remote_wakeup) {
+                        /* only enable appropriate wake bits, otherwise the
+                         * hardware can not go phy low power mode. If a race
+                         * condition happens here(connection change during bits
+                         * set), the port change detection will finally fix it.
+                         */
+                        if (t1 & PORT_CONNECT) {
+                                t2 |= PORT_WKOC_E | PORT_WKDISC_E;
+                                t2 &= ~PORT_WKCONN_E;
+                        } else {
+                                t2 |= PORT_WKOC_E | PORT_WKCONN_E;
+                                t2 &= ~PORT_WKDISC_E;
+                        }
+                } else
                         t2 &= ~PORT_WAKE_BITS;
 
                 if (t1 != t2) {
                         ehci_vdbg (ehci, "port %d, %08x -> %08x\n",
                                 port + 1, t1, t2);
                         ehci_writel(ehci, t2, reg);
+                        if (hostpc_reg) {
+                                u32     t3;
+
+                                msleep(5);/* 5ms for HCD enter low pwr mode */
+                                t3 = ehci_readl(ehci, hostpc_reg);
+                                ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg);
+                                t3 = ehci_readl(ehci, hostpc_reg);
+                                ehci_dbg(ehci, "Port%d phy low pwr mode %s\n",
+                                        port, (t3 & HOSTPC_PHCD) ?
+                                        "succeeded" : "failed");
+                        }
                 }
         }
 
@@ -183,6 +209,11 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
 
         ehci->next_statechange = jiffies + msecs_to_jiffies(10);
         spin_unlock_irq (&ehci->lock);
+
+        /* ehci_work() may have re-enabled the watchdog timer, which we do not
+         * want, and so we must delete any pending watchdog timer events.
+         */
+        del_timer_sync(&ehci->watchdog);
         return 0;
 }
 
@@ -204,6 +235,13 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 return -ESHUTDOWN;
         }
 
+        if (unlikely(ehci->debug)) {
+                if (ehci->debug && !dbgp_reset_prep())
+                        ehci->debug = NULL;
+                else
+                        dbgp_external_startup();
+        }
+
         /* Ideally and we've got a real resume here, and no port's power
          * was lost.  (For PCI, that means Vaux was maintained.)  But we
          * could instead be restoring a swsusp snapshot -- so that BIOS was
@@ -563,7 +601,8 @@ static int ehci_hub_control (
         int             ports = HCS_N_PORTS (ehci->hcs_params);
         u32 __iomem     *status_reg = &ehci->regs->port_status[
                                 (wIndex & 0xff) - 1];
-        u32             temp, status;
+        u32 __iomem     *hostpc_reg = NULL;
+        u32             temp, temp1, status;
         unsigned long   flags;
         int             retval = 0;
         unsigned        selector;
@@ -575,6 +614,9 @@ static int ehci_hub_control (
          * power, "this is the one", etc.  EHCI spec supports this.
          */
 
+        if (ehci->has_hostpc)
+                hostpc_reg = (u32 __iomem *)((u8 *)ehci->regs
+                                + HOSTPC0 + 4 * ((wIndex & 0xff) - 1));
         spin_lock_irqsave (&ehci->lock, flags);
         switch (typeReq) {
         case ClearHubFeature:
@@ -773,7 +815,11 @@ static int ehci_hub_control (
                 if (temp & PORT_CONNECT) {
                         status |= 1 << USB_PORT_FEAT_CONNECTION;
                         // status may be from integrated TT
-                        status |= ehci_port_speed(ehci, temp);
+                        if (ehci->has_hostpc) {
+                                temp1 = ehci_readl(ehci, hostpc_reg);
+                                status |= ehci_port_speed(ehci, temp1);
+                        } else
+                                status |= ehci_port_speed(ehci, temp);
                 }
                 if (temp & PORT_PE)
                         status |= 1 << USB_PORT_FEAT_ENABLE;
@@ -816,6 +862,15 @@ static int ehci_hub_control (
         case SetPortFeature:
                 selector = wIndex >> 8;
                 wIndex &= 0xff;
+                if (unlikely(ehci->debug)) {
+                        /* If the debug port is active any port
+                         * feature requests should get denied */
+                        if (wIndex == HCS_DEBUG_PORT(ehci->hcs_params) &&
+                            (readl(&ehci->debug->control) & DBGP_ENABLED)) {
+                                retval = -ENODEV;
+                                goto error_exit;
+                        }
+                }
                 if (!wIndex || wIndex > ports)
                         goto error;
                 wIndex--;
@@ -832,6 +887,24 @@ static int ehci_hub_control (
                                         || (temp & PORT_RESET) != 0)
                                 goto error;
                         ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
+                        /* After above check the port must be connected.
+                         * Set appropriate bit thus could put phy into low power
+                         * mode if we have hostpc feature
+                         */
+                        if (hostpc_reg) {
+                                temp &= ~PORT_WKCONN_E;
+                                temp |= (PORT_WKDISC_E | PORT_WKOC_E);
+                                ehci_writel(ehci, temp | PORT_SUSPEND,
+                                                        status_reg);
+                                msleep(5);/* 5ms for HCD enter low pwr mode */
+                                temp1 = ehci_readl(ehci, hostpc_reg);
+                                ehci_writel(ehci, temp1 | HOSTPC_PHCD,
+                                        hostpc_reg);
+                                temp1 = ehci_readl(ehci, hostpc_reg);
+                                ehci_dbg(ehci, "Port%d phy low pwr mode %s\n",
+                                        wIndex, (temp1 & HOSTPC_PHCD) ?
+                                        "succeeded" : "failed");
+                        }
                         set_bit(wIndex, &ehci->suspended_ports);
                         break;
                 case USB_PORT_FEAT_POWER:
@@ -894,6 +967,7 @@ error:
                 /* "stall" on error */
                 retval = -EPIPE;
         }
+error_exit:
         spin_unlock_irqrestore (&ehci->lock, flags);
         return retval;
 }
diff --git a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c
index 10d52919abbb..aeda96e0af67 100644
--- a/drivers/usb/host/ehci-mem.c
+++ b/drivers/usb/host/ehci-mem.c
@@ -75,7 +75,8 @@ static void qh_destroy(struct ehci_qh *qh)
         }
         if (qh->dummy)
                 ehci_qtd_free (ehci, qh->dummy);
-        dma_pool_free (ehci->qh_pool, qh, qh->qh_dma);
+        dma_pool_free(ehci->qh_pool, qh->hw, qh->qh_dma);
+        kfree(qh);
 }
 
 static struct ehci_qh *ehci_qh_alloc (struct ehci_hcd *ehci, gfp_t flags)
@@ -83,12 +84,14 @@ static struct ehci_qh *ehci_qh_alloc (struct ehci_hcd *ehci, gfp_t flags)
         struct ehci_qh          *qh;
         dma_addr_t              dma;
 
-        qh = (struct ehci_qh *)
-                dma_pool_alloc (ehci->qh_pool, flags, &dma);
+        qh = kzalloc(sizeof *qh, GFP_ATOMIC);
         if (!qh)
-                return qh;
-
-        memset (qh, 0, sizeof *qh);
+                goto done;
+        qh->hw = (struct ehci_qh_hw *)
+                dma_pool_alloc(ehci->qh_pool, flags, &dma);
+        if (!qh->hw)
+                goto fail;
+        memset(qh->hw, 0, sizeof *qh->hw);
         qh->refcount = 1;
         qh->ehci = ehci;
         qh->qh_dma = dma;
@@ -99,10 +102,15 @@ static struct ehci_qh *ehci_qh_alloc (struct ehci_hcd *ehci, gfp_t flags)
         qh->dummy = ehci_qtd_alloc (ehci, flags);
         if (qh->dummy == NULL) {
                 ehci_dbg (ehci, "no dummy td\n");
-                dma_pool_free (ehci->qh_pool, qh, qh->qh_dma);
-                qh = NULL;
+                goto fail1;
         }
+done:
         return qh;
+fail1:
+        dma_pool_free(ehci->qh_pool, qh->hw, qh->qh_dma);
+fail:
+        kfree(qh);
+        return NULL;
 }
 
 /* to share a qh (cpu threads, or hc) */
@@ -180,7 +188,7 @@ static int ehci_mem_init (struct ehci_hcd *ehci, gfp_t flags)
         /* QHs for control/bulk/intr transfers */
         ehci->qh_pool = dma_pool_create ("ehci_qh",
                         ehci_to_hcd(ehci)->self.controller,
-                        sizeof (struct ehci_qh),
+                        sizeof(struct ehci_qh_hw),
                         32 /* byte alignment (for hw parts) */,
                         4096 /* can't cross 4K */);
         if (!ehci->qh_pool) {
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index b5b83c43898a..378861b9d79a 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -27,28 +27,8 @@
 /* called after powerup, by probe or system-pm "wakeup" */
 static int ehci_pci_reinit(struct ehci_hcd *ehci, struct pci_dev *pdev)
 {
-        u32                     temp;
         int                     retval;
 
-        /* optional debug port, normally in the first BAR */
-        temp = pci_find_capability(pdev, 0x0a);
-        if (temp) {
-                pci_read_config_dword(pdev, temp, &temp);
-                temp >>= 16;
-                if ((temp & (3 << 13)) == (1 << 13)) {
-                        temp &= 0x1fff;
-                        ehci->debug = ehci_to_hcd(ehci)->regs + temp;
-                        temp = ehci_readl(ehci, &ehci->debug->control);
-                        ehci_info(ehci, "debug port %d%s\n",
-                                HCS_DEBUG_PORT(ehci->hcs_params),
-                                (temp & DBGP_ENABLED)
-                                        ? " IN USE"
-                                        : "");
-                        if (!(temp & DBGP_ENABLED))
-                                ehci->debug = NULL;
-                }
-        }
-
         /* we expect static quirk code to handle the "extended capabilities"
          * (currently just BIOS handoff) allowed starting with EHCI 0.96
          */
@@ -129,6 +109,9 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                 return retval;
 
         switch (pdev->vendor) {
+        case PCI_VENDOR_ID_INTEL:
+                ehci->need_io_watchdog = 0;
+                break;
         case PCI_VENDOR_ID_TDI:
                 if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) {
                         hcd->has_tt = 1;
@@ -192,6 +175,25 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                 break;
         }
 
+        /* optional debug port, normally in the first BAR */
+        temp = pci_find_capability(pdev, 0x0a);
+        if (temp) {
+                pci_read_config_dword(pdev, temp, &temp);
+                temp >>= 16;
+                if ((temp & (3 << 13)) == (1 << 13)) {
+                        temp &= 0x1fff;
+                        ehci->debug = ehci_to_hcd(ehci)->regs + temp;
+                        temp = ehci_readl(ehci, &ehci->debug->control);
+                        ehci_info(ehci, "debug port %d%s\n",
+                                HCS_DEBUG_PORT(ehci->hcs_params),
+                                (temp & DBGP_ENABLED)
+                                        ? " IN USE"
+                                        : "");
+                        if (!(temp & DBGP_ENABLED))
+                                ehci->debug = NULL;
+                }
+        }
+
         ehci_reset(ehci);
 
         /* at least the Genesys GL880S needs fixup here */
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 7673554fa64d..00ad9ce392ed 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -87,31 +87,33 @@ qtd_fill(struct ehci_hcd *ehci, struct ehci_qtd *qtd, dma_addr_t buf,
 static inline void
 qh_update (struct ehci_hcd *ehci, struct ehci_qh *qh, struct ehci_qtd *qtd)
 {
+        struct ehci_qh_hw *hw = qh->hw;
+
         /* writes to an active overlay are unsafe */
         BUG_ON(qh->qh_state != QH_STATE_IDLE);
 
-        qh->hw_qtd_next = QTD_NEXT(ehci, qtd->qtd_dma);
-        qh->hw_alt_next = EHCI_LIST_END(ehci);
+        hw->hw_qtd_next = QTD_NEXT(ehci, qtd->qtd_dma);
+        hw->hw_alt_next = EHCI_LIST_END(ehci);
 
         /* Except for control endpoints, we make hardware maintain data
          * toggle (like OHCI) ... here (re)initialize the toggle in the QH,
          * and set the pseudo-toggle in udev. Only usb_clear_halt() will
          * ever clear it.
          */
-        if (!(qh->hw_info1 & cpu_to_hc32(ehci, 1 << 14))) {
+        if (!(hw->hw_info1 & cpu_to_hc32(ehci, 1 << 14))) {
                 unsigned        is_out, epnum;
 
                 is_out = !(qtd->hw_token & cpu_to_hc32(ehci, 1 << 8));
-                epnum = (hc32_to_cpup(ehci, &qh->hw_info1) >> 8) & 0x0f;
+                epnum = (hc32_to_cpup(ehci, &hw->hw_info1) >> 8) & 0x0f;
                 if (unlikely (!usb_gettoggle (qh->dev, epnum, is_out))) {
-                        qh->hw_token &= ~cpu_to_hc32(ehci, QTD_TOGGLE);
+                        hw->hw_token &= ~cpu_to_hc32(ehci, QTD_TOGGLE);
                         usb_settoggle (qh->dev, epnum, is_out, 1);
                 }
         }
 
         /* HC must see latest qtd and qh data before we clear ACTIVE+HALT */
         wmb ();
-        qh->hw_token &= cpu_to_hc32(ehci, QTD_TOGGLE | QTD_STS_PING);
+        hw->hw_token &= cpu_to_hc32(ehci, QTD_TOGGLE | QTD_STS_PING);
 }
 
 /* if it weren't for a common silicon quirk (writing the dummy into the qh
@@ -129,7 +131,7 @@ qh_refresh (struct ehci_hcd *ehci, struct ehci_qh *qh)
                 qtd = list_entry (qh->qtd_list.next,
                                 struct ehci_qtd, qtd_list);
                 /* first qtd may already be partially processed */
-                if (cpu_to_hc32(ehci, qtd->qtd_dma) == qh->hw_current)
+                if (cpu_to_hc32(ehci, qtd->qtd_dma) == qh->hw->hw_current)
                         qtd = NULL;
         }
 
@@ -260,7 +262,7 @@ __acquires(ehci->lock)
                 struct ehci_qh  *qh = (struct ehci_qh *) urb->hcpriv;
 
                 /* S-mask in a QH means it's an interrupt urb */
-                if ((qh->hw_info2 & cpu_to_hc32(ehci, QH_SMASK)) != 0) {
+                if ((qh->hw->hw_info2 & cpu_to_hc32(ehci, QH_SMASK)) != 0) {
 
                         /* ... update hc-wide periodic stats (for usbfs) */
                         ehci_to_hcd(ehci)->self.bandwidth_int_reqs--;
@@ -297,7 +299,6 @@ __acquires(ehci->lock)
 static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh);
 static void unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh);
 
-static void intr_deschedule (struct ehci_hcd *ehci, struct ehci_qh *qh);
 static int qh_schedule (struct ehci_hcd *ehci, struct ehci_qh *qh);
 
 /*
@@ -308,13 +309,14 @@ static int qh_schedule (struct ehci_hcd *ehci, struct ehci_qh *qh);
 static unsigned
 qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
 {
-        struct ehci_qtd         *last = NULL, *end = qh->dummy;
+        struct ehci_qtd         *last, *end = qh->dummy;
         struct list_head        *entry, *tmp;
-        int                     last_status = -EINPROGRESS;
+        int                     last_status;
         int                     stopped;
         unsigned                count = 0;
         u8                      state;
-        __le32                  halt = HALT_BIT(ehci);
+        const __le32            halt = HALT_BIT(ehci);
+        struct ehci_qh_hw       *hw = qh->hw;
 
         if (unlikely (list_empty (&qh->qtd_list)))
                 return count;
@@ -324,11 +326,20 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
          * they add urbs to this qh's queue or mark them for unlinking.
          *
          * NOTE:  unlinking expects to be done in queue order.
+         *
+         * It's a bug for qh->qh_state to be anything other than
+         * QH_STATE_IDLE, unless our caller is scan_async() or
+         * scan_periodic().
          */
         state = qh->qh_state;
         qh->qh_state = QH_STATE_COMPLETING;
         stopped = (state == QH_STATE_IDLE);
 
+ rescan:
+        last = NULL;
+        last_status = -EINPROGRESS;
+        qh->needs_rescan = 0;
+
         /* remove de-activated QTDs from front of queue.
          * after faults (including short reads), cleanup this urb
          * then let the queue advance.
@@ -392,7 +403,8 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                                         qtd->hw_token = cpu_to_hc32(ehci,
                                                         token);
                                         wmb();
-                                        qh->hw_token = cpu_to_hc32(ehci, token);
+                                        hw->hw_token = cpu_to_hc32(ehci,
+                                                        token);
                                         goto retry_xacterr;
                                 }
                                 stopped = 1;
@@ -435,8 +447,8 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                         /* qh unlinked; token in overlay may be most current */
                         if (state == QH_STATE_IDLE
                                         && cpu_to_hc32(ehci, qtd->qtd_dma)
-                                                == qh->hw_current) {
-                                token = hc32_to_cpu(ehci, qh->hw_token);
+                                                == hw->hw_current) {
+                                token = hc32_to_cpu(ehci, hw->hw_token);
 
                                 /* An unlink may leave an incomplete
                                  * async transaction in the TT buffer.
@@ -449,9 +461,9 @@ qh_completions (struct ehci_hcd *ehci, struct ehci_qh *qh)
                          * patch the qh later and so that completions can't
                          * activate it while we "know" it's stopped.
                          */
-                        if ((halt & qh->hw_token) == 0) {
+                        if ((halt & hw->hw_token) == 0) {
 halt:
-                                qh->hw_token |= halt;
+                                hw->hw_token |= halt;
                                 wmb ();
                         }
                 }
@@ -503,6 +515,21 @@ halt:
                 ehci_qtd_free (ehci, last);
         }
 
+        /* Do we need to rescan for URBs dequeued during a giveback? */
+        if (unlikely(qh->needs_rescan)) {
+                /* If the QH is already unlinked, do the rescan now. */
+                if (state == QH_STATE_IDLE)
+                        goto rescan;
+
+                /* Otherwise we have to wait until the QH is fully unlinked.
+                 * Our caller will start an unlink if qh->needs_rescan is
+                 * set.  But if an unlink has already started, nothing needs
+                 * to be done.
+                 */
+                if (state != QH_STATE_LINKED)
+                        qh->needs_rescan = 0;
+        }
+
         /* restore original state; caller must unlink or relink */
         qh->qh_state = state;
 
@@ -510,7 +537,7 @@ halt:
          * it after fault cleanup, or recovering from silicon wrongly
          * overlaying the dummy qtd (which reduces DMA chatter).
          */
-        if (stopped != 0 || qh->hw_qtd_next == EHCI_LIST_END(ehci)) {
+        if (stopped != 0 || hw->hw_qtd_next == EHCI_LIST_END(ehci)) {
                 switch (state) {
                 case QH_STATE_IDLE:
                         qh_refresh(ehci, qh);
@@ -527,12 +554,9 @@ halt:
                          * That should be rare for interrupt transfers,
                          * except maybe high bandwidth ...
                          */
-                        if ((cpu_to_hc32(ehci, QH_SMASK)
-                                        & qh->hw_info2) != 0) {
-                                intr_deschedule (ehci, qh);
-                                (void) qh_schedule (ehci, qh);
-                        } else
-                                unlink_async (ehci, qh);
+
+                        /* Tell the caller to start an unlink */
+                        qh->needs_rescan = 1;
                         break;
                 /* otherwise, unlink already started */
                 }
@@ -649,7 +673,7 @@ qh_urb_transaction (
                  * (this will usually be overridden later.)
                  */
                 if (is_input)
-                        qtd->hw_alt_next = ehci->async->hw_alt_next;
+                        qtd->hw_alt_next = ehci->async->hw->hw_alt_next;
 
                 /* qh makes control packets use qtd toggle; maybe switch it */
                 if ((maxpacket & (this_qtd_len + (maxpacket - 1))) == 0)
@@ -744,6 +768,7 @@ qh_make (
         int                     is_input, type;
         int                     maxp = 0;
         struct usb_tt           *tt = urb->dev->tt;
+        struct ehci_qh_hw       *hw;
 
         if (!qh)
                 return qh;
@@ -890,8 +915,9 @@ done:
 
         /* init as live, toggle clear, advance to dummy */
         qh->qh_state = QH_STATE_IDLE;
-        qh->hw_info1 = cpu_to_hc32(ehci, info1);
-        qh->hw_info2 = cpu_to_hc32(ehci, info2);
+        hw = qh->hw;
+        hw->hw_info1 = cpu_to_hc32(ehci, info1);
+        hw->hw_info2 = cpu_to_hc32(ehci, info2);
         usb_settoggle (urb->dev, usb_pipeendpoint (urb->pipe), !is_input, 1);
         qh_refresh (ehci, qh);
         return qh;
@@ -910,6 +936,8 @@ static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
         if (unlikely(qh->clearing_tt))
                 return;
 
+        WARN_ON(qh->qh_state != QH_STATE_IDLE);
+
         /* (re)start the async schedule? */
         head = ehci->async;
         timer_action_done (ehci, TIMER_ASYNC_OFF);
@@ -928,16 +956,15 @@ static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
         }
 
         /* clear halt and/or toggle; and maybe recover from silicon quirk */
-        if (qh->qh_state == QH_STATE_IDLE)
-                qh_refresh (ehci, qh);
+        qh_refresh(ehci, qh);
 
         /* splice right after start */
         qh->qh_next = head->qh_next;
-        qh->hw_next = head->hw_next;
+        qh->hw->hw_next = head->hw->hw_next;
         wmb ();
 
         head->qh_next.qh = qh;
-        head->hw_next = dma;
+        head->hw->hw_next = dma;
 
         qh_get(qh);
         qh->xacterrs = 0;
@@ -984,7 +1011,7 @@ static struct ehci_qh *qh_append_tds (
 
                         /* usb_reset_device() briefly reverts to address 0 */
                         if (usb_pipedevice (urb->pipe) == 0)
-                                qh->hw_info1 &= ~qh_addr_mask;
+                                qh->hw->hw_info1 &= ~qh_addr_mask;
                 }
 
                 /* just one way to queue requests: swap with the dummy qtd.
@@ -1169,7 +1196,7 @@ static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
         while (prev->qh_next.qh != qh)
                 prev = prev->qh_next.qh;
 
-        prev->hw_next = qh->hw_next;
+        prev->hw->hw_next = qh->hw->hw_next;
         prev->qh_next = qh->qh_next;
         wmb ();
 
@@ -1214,6 +1241,8 @@ rescan:
                                 qh = qh_get (qh);
                                 qh->stamp = ehci->stamp;
                                 temp = qh_completions (ehci, qh);
+                                if (qh->needs_rescan)
+                                        unlink_async(ehci, qh);
                                 qh_put (qh);
                                 if (temp != 0) {
                                         goto rescan;
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index edd61ee90323..3ea05936851f 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -60,6 +60,20 @@ periodic_next_shadow(struct ehci_hcd *ehci, union ehci_shadow *periodic,
         }
 }
 
+static __hc32 *
+shadow_next_periodic(struct ehci_hcd *ehci, union ehci_shadow *periodic,
+                __hc32 tag)
+{
+        switch (hc32_to_cpu(ehci, tag)) {
+        /* our ehci_shadow.qh is actually software part */
+        case Q_TYPE_QH:
+                return &periodic->qh->hw->hw_next;
+        /* others are hw parts */
+        default:
+                return periodic->hw_next;
+        }
+}
+
 /* caller must hold ehci->lock */
 static void periodic_unlink (struct ehci_hcd *ehci, unsigned frame, void *ptr)
 {
@@ -71,7 +85,8 @@ static void periodic_unlink (struct ehci_hcd *ehci, unsigned frame, void *ptr)
         while (here.ptr && here.ptr != ptr) {
                 prev_p = periodic_next_shadow(ehci, prev_p,
                                 Q_NEXT_TYPE(ehci, *hw_p));
-                hw_p = here.hw_next;
+                hw_p = shadow_next_periodic(ehci, &here,
+                                Q_NEXT_TYPE(ehci, *hw_p));
                 here = *prev_p;
         }
         /* an interrupt entry (at list end) could have been shared */
@@ -83,7 +98,7 @@ static void periodic_unlink (struct ehci_hcd *ehci, unsigned frame, void *ptr)
          */
         *prev_p = *periodic_next_shadow(ehci, &here,
                         Q_NEXT_TYPE(ehci, *hw_p));
-        *hw_p = *here.hw_next;
+        *hw_p = *shadow_next_periodic(ehci, &here, Q_NEXT_TYPE(ehci, *hw_p));
 }
 
 /* how many of the uframe's 125 usecs are allocated? */
@@ -93,18 +108,20 @@ periodic_usecs (struct ehci_hcd *ehci, unsigned frame, unsigned uframe)
         __hc32                  *hw_p = &ehci->periodic [frame];
         union ehci_shadow       *q = &ehci->pshadow [frame];
         unsigned                usecs = 0;
+        struct ehci_qh_hw       *hw;
 
         while (q->ptr) {
                 switch (hc32_to_cpu(ehci, Q_NEXT_TYPE(ehci, *hw_p))) {
                 case Q_TYPE_QH:
+                        hw = q->qh->hw;
                         /* is it in the S-mask? */
-                        if (q->qh->hw_info2 & cpu_to_hc32(ehci, 1 << uframe))
+                        if (hw->hw_info2 & cpu_to_hc32(ehci, 1 << uframe))
                                 usecs += q->qh->usecs;
                         /* ... or C-mask? */
-                        if (q->qh->hw_info2 & cpu_to_hc32(ehci,
+                        if (hw->hw_info2 & cpu_to_hc32(ehci,
                                         1 << (8 + uframe)))
                                 usecs += q->qh->c_usecs;
-                        hw_p = &q->qh->hw_next;
+                        hw_p = &hw->hw_next;
                         q = &q->qh->qh_next;
                         break;
                 // case Q_TYPE_FSTN:
@@ -237,10 +254,10 @@ periodic_tt_usecs (
                         continue;
                 case Q_TYPE_QH:
                         if (same_tt(dev, q->qh->dev)) {
-                                uf = tt_start_uframe(ehci, q->qh->hw_info2);
+                                uf = tt_start_uframe(ehci, q->qh->hw->hw_info2);
                                 tt_usecs[uf] += q->qh->tt_usecs;
                         }
-                        hw_p = &q->qh->hw_next;
+                        hw_p = &q->qh->hw->hw_next;
                         q = &q->qh->qh_next;
                         continue;
                 case Q_TYPE_SITD:
@@ -375,6 +392,7 @@ static int tt_no_collision (
         for (; frame < ehci->periodic_size; frame += period) {
                 union ehci_shadow       here;
                 __hc32                  type;
+                struct ehci_qh_hw       *hw;
 
                 here = ehci->pshadow [frame];
                 type = Q_NEXT_TYPE(ehci, ehci->periodic [frame]);
@@ -385,17 +403,18 @@ static int tt_no_collision (
                                 here = here.itd->itd_next;
                                 continue;
                         case Q_TYPE_QH:
+                                hw = here.qh->hw;
                                 if (same_tt (dev, here.qh->dev)) {
                                         u32             mask;
 
                                         mask = hc32_to_cpu(ehci,
-                                                        here.qh->hw_info2);
+                                                        hw->hw_info2);
                                         /* "knows" no gap is needed */
                                         mask |= mask >> 8;
                                         if (mask & uf_mask)
                                                 break;
                                 }
-                                type = Q_NEXT_TYPE(ehci, here.qh->hw_next);
+                                type = Q_NEXT_TYPE(ehci, hw->hw_next);
                                 here = here.qh->qh_next;
                                 continue;
                         case Q_TYPE_SITD:
@@ -498,7 +517,8 @@ static int qh_link_periodic (struct ehci_hcd *ehci, struct ehci_qh *qh)
 
         dev_dbg (&qh->dev->dev,
                 "link qh%d-%04x/%p start %d [%d/%d us]\n",
-                period, hc32_to_cpup(ehci, &qh->hw_info2) & (QH_CMASK | QH_SMASK),
+                period, hc32_to_cpup(ehci, &qh->hw->hw_info2)
+                        & (QH_CMASK | QH_SMASK),
                 qh, qh->start, qh->usecs, qh->c_usecs);
 
         /* high bandwidth, or otherwise every microframe */
@@ -517,7 +537,7 @@ static int qh_link_periodic (struct ehci_hcd *ehci, struct ehci_qh *qh)
                         if (type == cpu_to_hc32(ehci, Q_TYPE_QH))
                                 break;
                         prev = periodic_next_shadow(ehci, prev, type);
-                        hw_p = &here.qh->hw_next;
+                        hw_p = shadow_next_periodic(ehci, &here, type);
                         here = *prev;
                 }
 
@@ -528,14 +548,14 @@ static int qh_link_periodic (struct ehci_hcd *ehci, struct ehci_qh *qh)
                         if (qh->period > here.qh->period)
                                 break;
                         prev = &here.qh->qh_next;
-                        hw_p = &here.qh->hw_next;
+                        hw_p = &here.qh->hw->hw_next;
                         here = *prev;
                 }
                 /* link in this qh, unless some earlier pass did that */
                 if (qh != here.qh) {
                         qh->qh_next = here;
                         if (here.qh)
-                                qh->hw_next = *hw_p;
+                                qh->hw->hw_next = *hw_p;
                         wmb ();
                         prev->qh = qh;
                         *hw_p = QH_NEXT (ehci, qh->qh_dma);
@@ -581,7 +601,7 @@ static int qh_unlink_periodic(struct ehci_hcd *ehci, struct ehci_qh *qh)
         dev_dbg (&qh->dev->dev,
                 "unlink qh%d-%04x/%p start %d [%d/%d us]\n",
                 qh->period,
-                hc32_to_cpup(ehci, &qh->hw_info2) & (QH_CMASK | QH_SMASK),
+                hc32_to_cpup(ehci, &qh->hw->hw_info2) & (QH_CMASK | QH_SMASK),
                 qh, qh->start, qh->usecs, qh->c_usecs);
 
         /* qh->qh_next still "live" to HC */
@@ -595,7 +615,19 @@ static int qh_unlink_periodic(struct ehci_hcd *ehci, struct ehci_qh *qh)
 
 static void intr_deschedule (struct ehci_hcd *ehci, struct ehci_qh *qh)
 {
-        unsigned        wait;
+        unsigned                wait;
+        struct ehci_qh_hw       *hw = qh->hw;
+        int                     rc;
+
+        /* If the QH isn't linked then there's nothing we can do
+         * unless we were called during a giveback, in which case
+         * qh_completions() has to deal with it.
+         */
+        if (qh->qh_state != QH_STATE_LINKED) {
+                if (qh->qh_state == QH_STATE_COMPLETING)
+                        qh->needs_rescan = 1;
+                return;
+        }
 
         qh_unlink_periodic (ehci, qh);
 
@@ -606,15 +638,33 @@ static void intr_deschedule (struct ehci_hcd *ehci, struct ehci_qh *qh)
          */
         if (list_empty (&qh->qtd_list)
                         || (cpu_to_hc32(ehci, QH_CMASK)
-                                        & qh->hw_info2) != 0)
+                                        & hw->hw_info2) != 0)
                 wait = 2;
         else
                 wait = 55;      /* worst case: 3 * 1024 */
 
         udelay (wait);
         qh->qh_state = QH_STATE_IDLE;
-        qh->hw_next = EHCI_LIST_END(ehci);
+        hw->hw_next = EHCI_LIST_END(ehci);
         wmb ();
+
+        qh_completions(ehci, qh);
+
+        /* reschedule QH iff another request is queued */
+        if (!list_empty(&qh->qtd_list) &&
+                        HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
+                rc = qh_schedule(ehci, qh);
+
+                /* An error here likely indicates handshake failure
+                 * or no space left in the schedule.  Neither fault
+                 * should happen often ...
+                 *
+                 * FIXME kill the now-dysfunctional queued urbs
+                 */
+                if (rc != 0)
+                        ehci_err(ehci, "can't reschedule qh %p, err %d\n",
+                                        qh, rc);
+        }
 }
 
 /*-------------------------------------------------------------------------*/
@@ -739,14 +789,15 @@ static int qh_schedule(struct ehci_hcd *ehci, struct ehci_qh *qh)
         unsigned        uframe;
         __hc32          c_mask;
         unsigned        frame;          /* 0..(qh->period - 1), or NO_FRAME */
+        struct ehci_qh_hw       *hw = qh->hw;
 
         qh_refresh(ehci, qh);
-        qh->hw_next = EHCI_LIST_END(ehci);
+        hw->hw_next = EHCI_LIST_END(ehci);
         frame = qh->start;
 
         /* reuse the previous schedule slots, if we can */
         if (frame < qh->period) {
-                uframe = ffs(hc32_to_cpup(ehci, &qh->hw_info2) & QH_SMASK);
+                uframe = ffs(hc32_to_cpup(ehci, &hw->hw_info2) & QH_SMASK);
                 status = check_intr_schedule (ehci, frame, --uframe,
                                 qh, &c_mask);
         } else {
@@ -784,11 +835,11 @@ static int qh_schedule(struct ehci_hcd *ehci, struct ehci_qh *qh)
                 qh->start = frame;
 
                 /* reset S-frame and (maybe) C-frame masks */
-                qh->hw_info2 &= cpu_to_hc32(ehci, ~(QH_CMASK | QH_SMASK));
-                qh->hw_info2 |= qh->period
+                hw->hw_info2 &= cpu_to_hc32(ehci, ~(QH_CMASK | QH_SMASK));
+                hw->hw_info2 |= qh->period
                         ? cpu_to_hc32(ehci, 1 << uframe)
                         : cpu_to_hc32(ehci, QH_SMASK);
-                qh->hw_info2 |= c_mask;
+                hw->hw_info2 |= c_mask;
         } else
                 ehci_dbg (ehci, "reused qh %p schedule\n", qh);
 
@@ -2188,10 +2239,11 @@ restart:
                         case Q_TYPE_QH:
                                 /* handle any completions */
                                 temp.qh = qh_get (q.qh);
-                                type = Q_NEXT_TYPE(ehci, q.qh->hw_next);
+                                type = Q_NEXT_TYPE(ehci, q.qh->hw->hw_next);
                                 q = q.qh->qh_next;
                                 modified = qh_completions (ehci, temp.qh);
-                                if (unlikely (list_empty (&temp.qh->qtd_list)))
+                                if (unlikely(list_empty(&temp.qh->qtd_list) ||
+                                                temp.qh->needs_rescan))
                                         intr_deschedule (ehci, temp.qh);
                                 qh_put (temp.qh);
                                 break;
diff --git a/drivers/usb/host/ehci-w90x900.c b/drivers/usb/host/ehci-w90x900.c
new file mode 100644
index 000000000000..cfa21ea20f82
--- /dev/null
+++ b/drivers/usb/host/ehci-w90x900.c
@@ -0,0 +1,181 @@
+/*
+ * linux/driver/usb/host/ehci-w90x900.c
+ *
+ * Copyright (c) 2008 Nuvoton technology corporation.
+ *
+ * Wan ZongShun <mcuos.com@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation;version 2 of the License.
+ *
+ */
+
+#include <linux/platform_device.h>
+
+/*ebable phy0 and phy1 for w90p910*/
+#define ENPHY           (0x01<<8)
+#define PHY0_CTR        (0xA4)
+#define PHY1_CTR        (0xA8)
+
+static int __devinit usb_w90x900_probe(const struct hc_driver *driver,
+                      struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci;
+        struct resource *res;
+        int retval = 0, irq;
+        unsigned long val;
+
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                retval = -ENXIO;
+                goto err1;
+        }
+
+        hcd = usb_create_hcd(driver, &pdev->dev, "w90x900 EHCI");
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto err1;
+        }
+
+        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)) {
+                retval = -EBUSY;
+                goto err2;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (hcd->regs == NULL) {
+                retval = -EFAULT;
+                goto err3;
+        }
+
+        ehci = hcd_to_ehci(hcd);
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs +
+                 HC_LENGTH(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
+        *  w90p910 IC relative to ehci->regs.
+        */
+        val = __raw_readl(ehci->regs+PHY0_CTR);
+        val |= ENPHY;
+        __raw_writel(val, ehci->regs+PHY0_CTR);
+
+        val = __raw_readl(ehci->regs+PHY1_CTR);
+        val |= ENPHY;
+        __raw_writel(val, ehci->regs+PHY1_CTR);
+
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+        ehci->sbrn = 0x20;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                goto err4;
+
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        if (retval != 0)
+                goto err4;
+
+        ehci_writel(ehci, 1, &ehci->regs->configured_flag);
+
+        return retval;
+err4:
+        iounmap(hcd->regs);
+err3:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err2:
+        usb_put_hcd(hcd);
+err1:
+        return retval;
+}
+
+static
+void usb_w90x900_remove(struct usb_hcd *hcd, struct platform_device *pdev)
+{
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+}
+
+static const struct hc_driver ehci_w90x900_hc_driver = {
+        .description = hcd_name,
+        .product_desc = "Nuvoton w90x900 EHCI Host Controller",
+        .hcd_priv_size = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq = ehci_irq,
+        .flags = HCD_USB2|HCD_MEMORY,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset = ehci_init,
+        .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,
+
+        /*
+         * 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,
+};
+
+static int __devinit ehci_w90x900_probe(struct platform_device *pdev)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        return usb_w90x900_probe(&ehci_w90x900_hc_driver, pdev);
+}
+
+static int __devexit ehci_w90x900_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_w90x900_remove(hcd, pdev);
+
+        return 0;
+}
+
+static struct platform_driver ehci_hcd_w90x900_driver = {
+        .probe  = ehci_w90x900_probe,
+        .remove = __devexit_p(ehci_w90x900_remove),
+        .driver = {
+                .name = "w90x900-ehci",
+                .owner = THIS_MODULE,
+        },
+};
+
+MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
+MODULE_DESCRIPTION("w90p910 usb ehci driver!");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:w90p910-ehci");
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 48b9e889a18b..064e76821ff5 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -126,6 +126,7 @@ struct ehci_hcd {			/* one per controller */
         unsigned                big_endian_mmio:1;
         unsigned                big_endian_desc:1;
         unsigned                has_amcc_usb23:1;
+        unsigned                need_io_watchdog:1;
 
         /* required for usb32 quirk */
         #define OHCI_CTRL_HCFS          (3 << 6)
@@ -135,6 +136,7 @@ struct ehci_hcd {			/* one per controller */
         #define OHCI_HCCTRL_OFFSET      0x4
         #define OHCI_HCCTRL_LEN         0x4
         __hc32                  *ohci_hcctrl_reg;
+        unsigned                has_hostpc:1;
 
         u8                      sbrn;           /* packed release number */
 
@@ -298,8 +300,8 @@ union ehci_shadow {
  * These appear in both the async and (for interrupt) periodic schedules.
  */
 
-struct ehci_qh {
-        /* first part defined by EHCI spec */
+/* first part defined by EHCI spec */
+struct ehci_qh_hw {
         __hc32                  hw_next;        /* see EHCI 3.6.1 */
         __hc32                  hw_info1;       /* see EHCI 3.6.2 */
 #define QH_HEAD         0x00008000
@@ -317,7 +319,10 @@ struct ehci_qh {
         __hc32                  hw_token;
         __hc32                  hw_buf [5];
         __hc32                  hw_buf_hi [5];
+} __attribute__ ((aligned(32)));
 
+struct ehci_qh {
+        struct ehci_qh_hw       *hw;
         /* the rest is HCD-private */
         dma_addr_t              qh_dma;         /* address of qh */
         union ehci_shadow       qh_next;        /* ptr to qh; or periodic */
@@ -336,6 +341,7 @@ struct ehci_qh {
         u32                     refcount;
         unsigned                stamp;
 
+        u8                      needs_rescan;   /* Dequeue during giveback */
         u8                      qh_state;
 #define QH_STATE_LINKED         1               /* HC sees this */
 #define QH_STATE_UNLINK         2               /* HC may still see this */
@@ -357,7 +363,7 @@ struct ehci_qh {
 
         struct usb_device       *dev;           /* access to TT */
         unsigned                clearing_tt:1;  /* Clear-TT-Buf in progress */
-} __attribute__ ((aligned (32)));
+};
 
 /*-------------------------------------------------------------------------*/
 
@@ -544,7 +550,7 @@ static inline unsigned int
 ehci_port_speed(struct ehci_hcd *ehci, unsigned int portsc)
 {
         if (ehci_is_TDI(ehci)) {
-                switch ((portsc>>26)&3) {
+                switch ((portsc >> (ehci->has_hostpc ? 25 : 26)) & 3) {
                 case 0:
                         return 0;
                 case 1:
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
new file mode 100644
index 000000000000..e35d82808bab
--- /dev/null
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -0,0 +1,2909 @@
+/*
+ * ISP1362 HCD (Host Controller Driver) for USB.
+ *
+ * Copyright (C) 2005 Lothar Wassmann <LW@KARO-electronics.de>
+ *
+ * Derived from the SL811 HCD, rewritten for ISP116x.
+ * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
+ *
+ * Portions:
+ * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
+ * Copyright (C) 2004 David Brownell
+ */
+
+/*
+ * The ISP1362 chip requires a large delay (300ns and 462ns) between
+ * accesses to the address and data register.
+ * The following timing options exist:
+ *
+ * 1. Configure your memory controller to add such delays if it can (the best)
+ * 2. Implement platform-specific delay function possibly
+ *    combined with configuring the memory controller; see
+ *    include/linux/usb_isp1362.h for more info.
+ * 3. Use ndelay (easiest, poorest).
+ *
+ * Use the corresponding macros USE_PLATFORM_DELAY and USE_NDELAY in the
+ * platform specific section of isp1362.h to select the appropriate variant.
+ *
+ * Also note that according to the Philips "ISP1362 Errata" document
+ * Rev 1.00 from 27 May data corruption may occur when the #WR signal
+ * is reasserted (even with #CS deasserted) within 132ns after a
+ * write cycle to any controller register. If the hardware doesn't
+ * implement the recommended fix (gating the #WR with #CS) software
+ * must ensure that no further write cycle (not necessarily to the chip!)
+ * is issued by the CPU within this interval.
+
+ * For PXA25x this can be ensured by using VLIO with the maximum
+ * recovery time (MSCx = 0x7f8c) with a memory clock of 99.53 MHz.
+ */
+
+#ifdef CONFIG_USB_DEBUG
+# define ISP1362_DEBUG
+#else
+# undef ISP1362_DEBUG
+#endif
+
+/*
+ * The PXA255 UDC apparently doesn't handle GET_STATUS, GET_CONFIG and
+ * GET_INTERFACE requests correctly when the SETUP and DATA stages of the
+ * requests are carried out in separate frames. This will delay any SETUP
+ * packets until the start of the next frame so that this situation is
+ * unlikely to occur (and makes usbtest happy running with a PXA255 target
+ * device).
+ */
+#undef BUGGY_PXA2XX_UDC_USBTEST
+
+#undef PTD_TRACE
+#undef URB_TRACE
+#undef VERBOSE
+#undef REGISTERS
+
+/* This enables a memory test on the ISP1362 chip memory to make sure the
+ * chip access timing is correct.
+ */
+#undef CHIP_BUFFER_TEST
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/ioport.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/smp_lock.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/usb.h>
+#include <linux/usb/isp1362.h>
+#include <linux/platform_device.h>
+#include <linux/pm.h>
+#include <linux/io.h>
+#include <linux/bitops.h>
+
+#include <asm/irq.h>
+#include <asm/system.h>
+#include <asm/byteorder.h>
+#include <asm/unaligned.h>
+
+static int dbg_level;
+#ifdef ISP1362_DEBUG
+module_param(dbg_level, int, 0644);
+#else
+module_param(dbg_level, int, 0);
+#define STUB_DEBUG_FILE
+#endif
+
+#include "../core/hcd.h"
+#include "../core/usb.h"
+#include "isp1362.h"
+
+
+#define DRIVER_VERSION  "2005-04-04"
+#define DRIVER_DESC     "ISP1362 USB Host Controller Driver"
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+static const char hcd_name[] = "isp1362-hcd";
+
+static void isp1362_hc_stop(struct usb_hcd *hcd);
+static int isp1362_hc_start(struct usb_hcd *hcd);
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * When called from the interrupthandler only isp1362_hcd->irqenb is modified,
+ * since the interrupt handler will write isp1362_hcd->irqenb to HCuPINT upon
+ * completion.
+ * We don't need a 'disable' counterpart, since interrupts will be disabled
+ * only by the interrupt handler.
+ */
+static inline void isp1362_enable_int(struct isp1362_hcd *isp1362_hcd, u16 mask)
+{
+        if ((isp1362_hcd->irqenb | mask) == isp1362_hcd->irqenb)
+                return;
+        if (mask & ~isp1362_hcd->irqenb)
+                isp1362_write_reg16(isp1362_hcd, HCuPINT, mask & ~isp1362_hcd->irqenb);
+        isp1362_hcd->irqenb |= mask;
+        if (isp1362_hcd->irq_active)
+                return;
+        isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static inline struct isp1362_ep_queue *get_ptd_queue(struct isp1362_hcd *isp1362_hcd,
+                                                     u16 offset)
+{
+        struct isp1362_ep_queue *epq = NULL;
+
+        if (offset < isp1362_hcd->istl_queue[1].buf_start)
+                epq = &isp1362_hcd->istl_queue[0];
+        else if (offset < isp1362_hcd->intl_queue.buf_start)
+                epq = &isp1362_hcd->istl_queue[1];
+        else if (offset < isp1362_hcd->atl_queue.buf_start)
+                epq = &isp1362_hcd->intl_queue;
+        else if (offset < isp1362_hcd->atl_queue.buf_start +
+                   isp1362_hcd->atl_queue.buf_size)
+                epq = &isp1362_hcd->atl_queue;
+
+        if (epq)
+                DBG(1, "%s: PTD $%04x is on %s queue\n", __func__, offset, epq->name);
+        else
+                pr_warning("%s: invalid PTD $%04x\n", __func__, offset);
+
+        return epq;
+}
+
+static inline int get_ptd_offset(struct isp1362_ep_queue *epq, u8 index)
+{
+        int offset;
+
+        if (index * epq->blk_size > epq->buf_size) {
+                pr_warning("%s: Bad %s index %d(%d)\n", __func__, epq->name, index,
+                     epq->buf_size / epq->blk_size);
+                return -EINVAL;
+        }
+        offset = epq->buf_start + index * epq->blk_size;
+        DBG(3, "%s: %s PTD[%02x] # %04x\n", __func__, epq->name, index, offset);
+
+        return offset;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static inline u16 max_transfer_size(struct isp1362_ep_queue *epq, size_t size,
+                                    int mps)
+{
+        u16 xfer_size = min_t(size_t, MAX_XFER_SIZE, size);
+
+        xfer_size = min_t(size_t, xfer_size, epq->buf_avail * epq->blk_size - PTD_HEADER_SIZE);
+        if (xfer_size < size && xfer_size % mps)
+                xfer_size -= xfer_size % mps;
+
+        return xfer_size;
+}
+
+static int claim_ptd_buffers(struct isp1362_ep_queue *epq,
+                             struct isp1362_ep *ep, u16 len)
+{
+        int ptd_offset = -EINVAL;
+        int index;
+        int num_ptds = ((len + PTD_HEADER_SIZE - 1) / epq->blk_size) + 1;
+        int found = -1;
+        int last = -1;
+
+        BUG_ON(len > epq->buf_size);
+
+        if (!epq->buf_avail)
+                return -ENOMEM;
+
+        if (ep->num_ptds)
+                pr_err("%s: %s len %d/%d num_ptds %d buf_map %08lx skip_map %08lx\n", __func__,
+                    epq->name, len, epq->blk_size, num_ptds, epq->buf_map, epq->skip_map);
+        BUG_ON(ep->num_ptds != 0);
+
+        for (index = 0; index <= epq->buf_count - num_ptds; index++) {
+                if (test_bit(index, &epq->buf_map))
+                        continue;
+                found = index;
+                for (last = index + 1; last < index + num_ptds; last++) {
+                        if (test_bit(last, &epq->buf_map)) {
+                                found = -1;
+                                break;
+                        }
+                }
+                if (found >= 0)
+                        break;
+        }
+        if (found < 0)
+                return -EOVERFLOW;
+
+        DBG(1, "%s: Found %d PTDs[%d] for %d/%d byte\n", __func__,
+            num_ptds, found, len, (int)(epq->blk_size - PTD_HEADER_SIZE));
+        ptd_offset = get_ptd_offset(epq, found);
+        WARN_ON(ptd_offset < 0);
+        ep->ptd_offset = ptd_offset;
+        ep->num_ptds += num_ptds;
+        epq->buf_avail -= num_ptds;
+        BUG_ON(epq->buf_avail > epq->buf_count);
+        ep->ptd_index = found;
+        for (index = found; index < last; index++)
+                __set_bit(index, &epq->buf_map);
+        DBG(1, "%s: Done %s PTD[%d] $%04x, avail %d count %d claimed %d %08lx:%08lx\n",
+            __func__, epq->name, ep->ptd_index, ep->ptd_offset,
+            epq->buf_avail, epq->buf_count, num_ptds, epq->buf_map, epq->skip_map);
+
+        return found;
+}
+
+static inline void release_ptd_buffers(struct isp1362_ep_queue *epq, struct isp1362_ep *ep)
+{
+        int index = ep->ptd_index;
+        int last = ep->ptd_index + ep->num_ptds;
+
+        if (last > epq->buf_count)
+                pr_err("%s: ep %p req %d len %d %s PTD[%d] $%04x num_ptds %d buf_count %d buf_avail %d buf_map %08lx skip_map %08lx\n",
+                    __func__, ep, ep->num_req, ep->length, epq->name, ep->ptd_index,
+                    ep->ptd_offset, ep->num_ptds, epq->buf_count, epq->buf_avail,
+                    epq->buf_map, epq->skip_map);
+        BUG_ON(last > epq->buf_count);
+
+        for (; index < last; index++) {
+                __clear_bit(index, &epq->buf_map);
+                __set_bit(index, &epq->skip_map);
+        }
+        epq->buf_avail += ep->num_ptds;
+        epq->ptd_count--;
+
+        BUG_ON(epq->buf_avail > epq->buf_count);
+        BUG_ON(epq->ptd_count > epq->buf_count);
+
+        DBG(1, "%s: Done %s PTDs $%04x released %d avail %d count %d\n",
+            __func__, epq->name,
+            ep->ptd_offset, ep->num_ptds, epq->buf_avail, epq->buf_count);
+        DBG(1, "%s: buf_map %08lx skip_map %08lx\n", __func__,
+            epq->buf_map, epq->skip_map);
+
+        ep->num_ptds = 0;
+        ep->ptd_offset = -EINVAL;
+        ep->ptd_index = -EINVAL;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+  Set up PTD's.
+*/
+static void prepare_ptd(struct isp1362_hcd *isp1362_hcd, struct urb *urb,
+                        struct isp1362_ep *ep, struct isp1362_ep_queue *epq,
+                        u16 fno)
+{
+        struct ptd *ptd;
+        int toggle;
+        int dir;
+        u16 len;
+        size_t buf_len = urb->transfer_buffer_length - urb->actual_length;
+
+        DBG(3, "%s: %s ep %p\n", __func__, epq->name, ep);
+
+        ptd = &ep->ptd;
+
+        ep->data = (unsigned char *)urb->transfer_buffer + urb->actual_length;
+
+        switch (ep->nextpid) {
+        case USB_PID_IN:
+                toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
+                dir = PTD_DIR_IN;
+                if (usb_pipecontrol(urb->pipe)) {
+                        len = min_t(size_t, ep->maxpacket, buf_len);
+                } else if (usb_pipeisoc(urb->pipe)) {
+                        len = min_t(size_t, urb->iso_frame_desc[fno].length, MAX_XFER_SIZE);
+                        ep->data = urb->transfer_buffer + urb->iso_frame_desc[fno].offset;
+                } else
+                        len = max_transfer_size(epq, buf_len, ep->maxpacket);
+                DBG(1, "%s: IN    len %d/%d/%d from URB\n", __func__, len, ep->maxpacket,
+                    (int)buf_len);
+                break;
+        case USB_PID_OUT:
+                toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
+                dir = PTD_DIR_OUT;
+                if (usb_pipecontrol(urb->pipe))
+                        len = min_t(size_t, ep->maxpacket, buf_len);
+                else if (usb_pipeisoc(urb->pipe))
+                        len = min_t(size_t, urb->iso_frame_desc[0].length, MAX_XFER_SIZE);
+                else
+                        len = max_transfer_size(epq, buf_len, ep->maxpacket);
+                if (len == 0)
+                        pr_info("%s: Sending ZERO packet: %d\n", __func__,
+                             urb->transfer_flags & URB_ZERO_PACKET);
+                DBG(1, "%s: OUT   len %d/%d/%d from URB\n", __func__, len, ep->maxpacket,
+                    (int)buf_len);
+                break;
+        case USB_PID_SETUP:
+                toggle = 0;
+                dir = PTD_DIR_SETUP;
+                len = sizeof(struct usb_ctrlrequest);
+                DBG(1, "%s: SETUP len %d\n", __func__, len);
+                ep->data = urb->setup_packet;
+                break;
+        case USB_PID_ACK:
+                toggle = 1;
+                len = 0;
+                dir = (urb->transfer_buffer_length && usb_pipein(urb->pipe)) ?
+                        PTD_DIR_OUT : PTD_DIR_IN;
+                DBG(1, "%s: ACK   len %d\n", __func__, len);
+                break;
+        default:
+                toggle = dir = len = 0;
+                pr_err("%s@%d: ep->nextpid %02x\n", __func__, __LINE__, ep->nextpid);
+                BUG_ON(1);
+        }
+
+        ep->length = len;
+        if (!len)
+                ep->data = NULL;
+
+        ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
+        ptd->mps = PTD_MPS(ep->maxpacket) | PTD_SPD(urb->dev->speed == USB_SPEED_LOW) |
+                PTD_EP(ep->epnum);
+        ptd->len = PTD_LEN(len) | PTD_DIR(dir);
+        ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
+
+        if (usb_pipeint(urb->pipe)) {
+                ptd->faddr |= PTD_SF_INT(ep->branch);
+                ptd->faddr |= PTD_PR(ep->interval ? __ffs(ep->interval) : 0);
+        }
+        if (usb_pipeisoc(urb->pipe))
+                ptd->faddr |= PTD_SF_ISO(fno);
+
+        DBG(1, "%s: Finished\n", __func__);
+}
+
+static void isp1362_write_ptd(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep,
+                              struct isp1362_ep_queue *epq)
+{
+        struct ptd *ptd = &ep->ptd;
+        int len = PTD_GET_DIR(ptd) == PTD_DIR_IN ? 0 : ep->length;
+
+        _BUG_ON(ep->ptd_offset < 0);
+
+        prefetch(ptd);
+        isp1362_write_buffer(isp1362_hcd, ptd, ep->ptd_offset, PTD_HEADER_SIZE);
+        if (len)
+                isp1362_write_buffer(isp1362_hcd, ep->data,
+                                     ep->ptd_offset + PTD_HEADER_SIZE, len);
+
+        dump_ptd(ptd);
+        dump_ptd_out_data(ptd, ep->data);
+}
+
+static void isp1362_read_ptd(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep,
+                             struct isp1362_ep_queue *epq)
+{
+        struct ptd *ptd = &ep->ptd;
+        int act_len;
+
+        WARN_ON(list_empty(&ep->active));
+        BUG_ON(ep->ptd_offset < 0);
+
+        list_del_init(&ep->active);
+        DBG(1, "%s: ep %p removed from active list %p\n", __func__, ep, &epq->active);
+
+        prefetchw(ptd);
+        isp1362_read_buffer(isp1362_hcd, ptd, ep->ptd_offset, PTD_HEADER_SIZE);
+        dump_ptd(ptd);
+        act_len = PTD_GET_COUNT(ptd);
+        if (PTD_GET_DIR(ptd) != PTD_DIR_IN || act_len == 0)
+                return;
+        if (act_len > ep->length)
+                pr_err("%s: ep %p PTD $%04x act_len %d ep->length %d\n", __func__, ep,
+                         ep->ptd_offset, act_len, ep->length);
+        BUG_ON(act_len > ep->length);
+        /* Only transfer the amount of data that has actually been overwritten
+         * in the chip buffer. We don't want any data that doesn't belong to the
+         * transfer to leak out of the chip to the callers transfer buffer!
+         */
+        prefetchw(ep->data);
+        isp1362_read_buffer(isp1362_hcd, ep->data,
+                            ep->ptd_offset + PTD_HEADER_SIZE, act_len);
+        dump_ptd_in_data(ptd, ep->data);
+}
+
+/*
+ * INT PTDs will stay in the chip until data is available.
+ * This function will remove a PTD from the chip when the URB is dequeued.
+ * Must be called with the spinlock held and IRQs disabled
+ */
+static void remove_ptd(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep)
+
+{
+        int index;
+        struct isp1362_ep_queue *epq;
+
+        DBG(1, "%s: ep %p PTD[%d] $%04x\n", __func__, ep, ep->ptd_index, ep->ptd_offset);
+        BUG_ON(ep->ptd_offset < 0);
+
+        epq = get_ptd_queue(isp1362_hcd, ep->ptd_offset);
+        BUG_ON(!epq);
+
+        /* put ep in remove_list for cleanup */
+        WARN_ON(!list_empty(&ep->remove_list));
+        list_add_tail(&ep->remove_list, &isp1362_hcd->remove_list);
+        /* let SOF interrupt handle the cleanup */
+        isp1362_enable_int(isp1362_hcd, HCuPINT_SOF);
+
+        index = ep->ptd_index;
+        if (index < 0)
+                /* ISO queues don't have SKIP registers */
+                return;
+
+        DBG(1, "%s: Disabling PTD[%02x] $%04x %08lx|%08x\n", __func__,
+            index, ep->ptd_offset, epq->skip_map, 1 << index);
+
+        /* prevent further processing of PTD (will be effective after next SOF) */
+        epq->skip_map |= 1 << index;
+        if (epq == &isp1362_hcd->atl_queue) {
+                DBG(2, "%s: ATLSKIP = %08x -> %08lx\n", __func__,
+                    isp1362_read_reg32(isp1362_hcd, HCATLSKIP), epq->skip_map);
+                isp1362_write_reg32(isp1362_hcd, HCATLSKIP, epq->skip_map);
+                if (~epq->skip_map == 0)
+                        isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
+        } else if (epq == &isp1362_hcd->intl_queue) {
+                DBG(2, "%s: INTLSKIP = %08x -> %08lx\n", __func__,
+                    isp1362_read_reg32(isp1362_hcd, HCINTLSKIP), epq->skip_map);
+                isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, epq->skip_map);
+                if (~epq->skip_map == 0)
+                        isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_INTL_ACTIVE);
+        }
+}
+
+/*
+  Take done or failed requests out of schedule. Give back
+  processed urbs.
+*/
+static void finish_request(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep,
+                           struct urb *urb, int status)
+     __releases(isp1362_hcd->lock)
+     __acquires(isp1362_hcd->lock)
+{
+        urb->hcpriv = NULL;
+        ep->error_count = 0;
+
+        if (usb_pipecontrol(urb->pipe))
+                ep->nextpid = USB_PID_SETUP;
+
+        URB_DBG("%s: req %d FA %d ep%d%s %s: len %d/%d %s stat %d\n", __func__,
+                ep->num_req, usb_pipedevice(urb->pipe),
+                usb_pipeendpoint(urb->pipe),
+                !usb_pipein(urb->pipe) ? "out" : "in",
+                usb_pipecontrol(urb->pipe) ? "ctrl" :
+                        usb_pipeint(urb->pipe) ? "int" :
+                        usb_pipebulk(urb->pipe) ? "bulk" :
+                        "iso",
+                urb->actual_length, urb->transfer_buffer_length,
+                !(urb->transfer_flags & URB_SHORT_NOT_OK) ?
+                "short_ok" : "", urb->status);
+
+
+        usb_hcd_unlink_urb_from_ep(isp1362_hcd_to_hcd(isp1362_hcd), urb);
+        spin_unlock(&isp1362_hcd->lock);
+        usb_hcd_giveback_urb(isp1362_hcd_to_hcd(isp1362_hcd), urb, status);
+        spin_lock(&isp1362_hcd->lock);
+
+        /* take idle endpoints out of the schedule right away */
+        if (!list_empty(&ep->hep->urb_list))
+                return;
+
+        /* async deschedule */
+        if (!list_empty(&ep->schedule)) {
+                list_del_init(&ep->schedule);
+                return;
+        }
+
+
+        if (ep->interval) {
+                /* periodic deschedule */
+                DBG(1, "deschedule qh%d/%p branch %d load %d bandwidth %d -> %d\n", ep->interval,
+                    ep, ep->branch, ep->load,
+                    isp1362_hcd->load[ep->branch],
+                    isp1362_hcd->load[ep->branch] - ep->load);
+                isp1362_hcd->load[ep->branch] -= ep->load;
+                ep->branch = PERIODIC_SIZE;
+        }
+}
+
+/*
+ * Analyze transfer results, handle partial transfers and errors
+*/
+static void postproc_ep(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep)
+{
+        struct urb *urb = get_urb(ep);
+        struct usb_device *udev;
+        struct ptd *ptd;
+        int short_ok;
+        u16 len;
+        int urbstat = -EINPROGRESS;
+        u8 cc;
+
+        DBG(2, "%s: ep %p req %d\n", __func__, ep, ep->num_req);
+
+        udev = urb->dev;
+        ptd = &ep->ptd;
+        cc = PTD_GET_CC(ptd);
+        if (cc == PTD_NOTACCESSED) {
+                pr_err("%s: req %d PTD %p Untouched by ISP1362\n", __func__,
+                    ep->num_req, ptd);
+                cc = PTD_DEVNOTRESP;
+        }
+
+        short_ok = !(urb->transfer_flags & URB_SHORT_NOT_OK);
+        len = urb->transfer_buffer_length - urb->actual_length;
+
+        /* Data underrun is special. For allowed underrun
+           we clear the error and continue as normal. For
+           forbidden underrun we finish the DATA stage
+           immediately while for control transfer,
+           we do a STATUS stage.
+        */
+        if (cc == PTD_DATAUNDERRUN) {
+                if (short_ok) {
+                        DBG(1, "%s: req %d Allowed data underrun short_%sok %d/%d/%d byte\n",
+                            __func__, ep->num_req, short_ok ? "" : "not_",
+                            PTD_GET_COUNT(ptd), ep->maxpacket, len);
+                        cc = PTD_CC_NOERROR;
+                        urbstat = 0;
+                } else {
+                        DBG(1, "%s: req %d Data Underrun %s nextpid %02x short_%sok %d/%d/%d byte\n",
+                            __func__, ep->num_req,
+                            usb_pipein(urb->pipe) ? "IN" : "OUT", ep->nextpid,
+                            short_ok ? "" : "not_",
+                            PTD_GET_COUNT(ptd), ep->maxpacket, len);
+                        if (usb_pipecontrol(urb->pipe)) {
+                                ep->nextpid = USB_PID_ACK;
+                                /* save the data underrun error code for later and
+                                 * procede with the status stage
+                                 */
+                                urb->actual_length += PTD_GET_COUNT(ptd);
+                                BUG_ON(urb->actual_length > urb->transfer_buffer_length);
+
+                                if (urb->status == -EINPROGRESS)
+                                        urb->status = cc_to_error[PTD_DATAUNDERRUN];
+                        } else {
+                                usb_settoggle(udev, ep->epnum, ep->nextpid == USB_PID_OUT,
+                                              PTD_GET_TOGGLE(ptd));
+                                urbstat = cc_to_error[PTD_DATAUNDERRUN];
+                        }
+                        goto out;
+                }
+        }
+
+        if (cc != PTD_CC_NOERROR) {
+                if (++ep->error_count >= 3 || cc == PTD_CC_STALL || cc == PTD_DATAOVERRUN) {
+                        urbstat = cc_to_error[cc];
+                        DBG(1, "%s: req %d nextpid %02x, status %d, error %d, error_count %d\n",
+                            __func__, ep->num_req, ep->nextpid, urbstat, cc,
+                            ep->error_count);
+                }
+                goto out;
+        }
+
+        switch (ep->nextpid) {
+        case USB_PID_OUT:
+                if (PTD_GET_COUNT(ptd) != ep->length)
+                        pr_err("%s: count=%d len=%d\n", __func__,
+                           PTD_GET_COUNT(ptd), ep->length);
+                BUG_ON(PTD_GET_COUNT(ptd) != ep->length);
+                urb->actual_length += ep->length;
+                BUG_ON(urb->actual_length > urb->transfer_buffer_length);
+                usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd));
+                if (urb->actual_length == urb->transfer_buffer_length) {
+                        DBG(3, "%s: req %d xfer complete %d/%d status %d -> 0\n", __func__,
+                            ep->num_req, len, ep->maxpacket, urbstat);
+                        if (usb_pipecontrol(urb->pipe)) {
+                                DBG(3, "%s: req %d %s Wait for ACK\n", __func__,
+                                    ep->num_req,
+                                    usb_pipein(urb->pipe) ? "IN" : "OUT");
+                                ep->nextpid = USB_PID_ACK;
+                        } else {
+                                if (len % ep->maxpacket ||
+                                    !(urb->transfer_flags & URB_ZERO_PACKET)) {
+                                        urbstat = 0;
+                                        DBG(3, "%s: req %d URB %s status %d count %d/%d/%d\n",
+                                            __func__, ep->num_req, usb_pipein(urb->pipe) ? "IN" : "OUT",
+                                            urbstat, len, ep->maxpacket, urb->actual_length);
+                                }
+                        }
+                }
+                break;
+        case USB_PID_IN:
+                len = PTD_GET_COUNT(ptd);
+                BUG_ON(len > ep->length);
+                urb->actual_length += len;
+                BUG_ON(urb->actual_length > urb->transfer_buffer_length);
+                usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd));
+                /* if transfer completed or (allowed) data underrun */
+                if ((urb->transfer_buffer_length == urb->actual_length) ||
+                    len % ep->maxpacket) {
+                        DBG(3, "%s: req %d xfer complete %d/%d status %d -> 0\n", __func__,
+                            ep->num_req, len, ep->maxpacket, urbstat);
+                        if (usb_pipecontrol(urb->pipe)) {
+                                DBG(3, "%s: req %d %s Wait for ACK\n", __func__,
+                                    ep->num_req,
+                                    usb_pipein(urb->pipe) ? "IN" : "OUT");
+                                ep->nextpid = USB_PID_ACK;
+                        } else {
+                                urbstat = 0;
+                                DBG(3, "%s: req %d URB %s status %d count %d/%d/%d\n",
+                                    __func__, ep->num_req, usb_pipein(urb->pipe) ? "IN" : "OUT",
+                                    urbstat, len, ep->maxpacket, urb->actual_length);
+                        }
+                }
+                break;
+        case USB_PID_SETUP:
+                if (urb->transfer_buffer_length == urb->actual_length) {
+                        ep->nextpid = USB_PID_ACK;
+                } else if (usb_pipeout(urb->pipe)) {
+                        usb_settoggle(udev, 0, 1, 1);
+                        ep->nextpid = USB_PID_OUT;
+                } else {
+                        usb_settoggle(udev, 0, 0, 1);
+                        ep->nextpid = USB_PID_IN;
+                }
+                break;
+        case USB_PID_ACK:
+                DBG(3, "%s: req %d got ACK %d -> 0\n", __func__, ep->num_req,
+                    urbstat);
+                WARN_ON(urbstat != -EINPROGRESS);
+                urbstat = 0;
+                ep->nextpid = 0;
+                break;
+        default:
+                BUG_ON(1);
+        }
+
+ out:
+        if (urbstat != -EINPROGRESS) {
+                DBG(2, "%s: Finishing ep %p req %d urb %p status %d\n", __func__,
+                    ep, ep->num_req, urb, urbstat);
+                finish_request(isp1362_hcd, ep, urb, urbstat);
+        }
+}
+
+static void finish_unlinks(struct isp1362_hcd *isp1362_hcd)
+{
+        struct isp1362_ep *ep;
+        struct isp1362_ep *tmp;
+
+        list_for_each_entry_safe(ep, tmp, &isp1362_hcd->remove_list, remove_list) {
+                struct isp1362_ep_queue *epq =
+                        get_ptd_queue(isp1362_hcd, ep->ptd_offset);
+                int index = ep->ptd_index;
+
+                BUG_ON(epq == NULL);
+                if (index >= 0) {
+                        DBG(1, "%s: remove PTD[%d] $%04x\n", __func__, index, ep->ptd_offset);
+                        BUG_ON(ep->num_ptds == 0);
+                        release_ptd_buffers(epq, ep);
+                }
+                if (!list_empty(&ep->hep->urb_list)) {
+                        struct urb *urb = get_urb(ep);
+
+                        DBG(1, "%s: Finishing req %d ep %p from remove_list\n", __func__,
+                            ep->num_req, ep);
+                        finish_request(isp1362_hcd, ep, urb, -ESHUTDOWN);
+                }
+                WARN_ON(list_empty(&ep->active));
+                if (!list_empty(&ep->active)) {
+                        list_del_init(&ep->active);
+                        DBG(1, "%s: ep %p removed from active list\n", __func__, ep);
+                }
+                list_del_init(&ep->remove_list);
+                DBG(1, "%s: ep %p removed from remove_list\n", __func__, ep);
+        }
+        DBG(1, "%s: Done\n", __func__);
+}
+
+static inline void enable_atl_transfers(struct isp1362_hcd *isp1362_hcd, int count)
+{
+        if (count > 0) {
+                if (count < isp1362_hcd->atl_queue.ptd_count)
+                        isp1362_write_reg16(isp1362_hcd, HCATLDTC, count);
+                isp1362_enable_int(isp1362_hcd, HCuPINT_ATL);
+                isp1362_write_reg32(isp1362_hcd, HCATLSKIP, isp1362_hcd->atl_queue.skip_map);
+                isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
+        } else
+                isp1362_enable_int(isp1362_hcd, HCuPINT_SOF);
+}
+
+static inline void enable_intl_transfers(struct isp1362_hcd *isp1362_hcd)
+{
+        isp1362_enable_int(isp1362_hcd, HCuPINT_INTL);
+        isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_INTL_ACTIVE);
+        isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, isp1362_hcd->intl_queue.skip_map);
+}
+
+static inline void enable_istl_transfers(struct isp1362_hcd *isp1362_hcd, int flip)
+{
+        isp1362_enable_int(isp1362_hcd, flip ? HCuPINT_ISTL1 : HCuPINT_ISTL0);
+        isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, flip ?
+                           HCBUFSTAT_ISTL1_FULL : HCBUFSTAT_ISTL0_FULL);
+}
+
+static int submit_req(struct isp1362_hcd *isp1362_hcd, struct urb *urb,
+                      struct isp1362_ep *ep, struct isp1362_ep_queue *epq)
+{
+        int index = epq->free_ptd;
+
+        prepare_ptd(isp1362_hcd, urb, ep, epq, 0);
+        index = claim_ptd_buffers(epq, ep, ep->length);
+        if (index == -ENOMEM) {
+                DBG(1, "%s: req %d No free %s PTD available: %d, %08lx:%08lx\n", __func__,
+                    ep->num_req, epq->name, ep->num_ptds, epq->buf_map, epq->skip_map);
+                return index;
+        } else if (index == -EOVERFLOW) {
+                DBG(1, "%s: req %d Not enough space for %d byte %s PTD %d %08lx:%08lx\n",
+                    __func__, ep->num_req, ep->length, epq->name, ep->num_ptds,
+                    epq->buf_map, epq->skip_map);
+                return index;
+        } else
+                BUG_ON(index < 0);
+        list_add_tail(&ep->active, &epq->active);
+        DBG(1, "%s: ep %p req %d len %d added to active list %p\n", __func__,
+            ep, ep->num_req, ep->length, &epq->active);
+        DBG(1, "%s: Submitting %s PTD $%04x for ep %p req %d\n", __func__, epq->name,
+            ep->ptd_offset, ep, ep->num_req);
+        isp1362_write_ptd(isp1362_hcd, ep, epq);
+        __clear_bit(ep->ptd_index, &epq->skip_map);
+
+        return 0;
+}
+
+static void start_atl_transfers(struct isp1362_hcd *isp1362_hcd)
+{
+        int ptd_count = 0;
+        struct isp1362_ep_queue *epq = &isp1362_hcd->atl_queue;
+        struct isp1362_ep *ep;
+        int defer = 0;
+
+        if (atomic_read(&epq->finishing)) {
+                DBG(1, "%s: finish_transfers is active for %s\n", __func__, epq->name);
+                return;
+        }
+
+        list_for_each_entry(ep, &isp1362_hcd->async, schedule) {
+                struct urb *urb = get_urb(ep);
+                int ret;
+
+                if (!list_empty(&ep->active)) {
+                        DBG(2, "%s: Skipping active %s ep %p\n", __func__, epq->name, ep);
+                        continue;
+                }
+
+                DBG(1, "%s: Processing %s ep %p req %d\n", __func__, epq->name,
+                    ep, ep->num_req);
+
+                ret = submit_req(isp1362_hcd, urb, ep, epq);
+                if (ret == -ENOMEM) {
+                        defer = 1;
+                        break;
+                } else if (ret == -EOVERFLOW) {
+                        defer = 1;
+                        continue;
+                }
+#ifdef BUGGY_PXA2XX_UDC_USBTEST
+                defer = ep->nextpid == USB_PID_SETUP;
+#endif
+                ptd_count++;
+        }
+
+        /* Avoid starving of endpoints */
+        if (isp1362_hcd->async.next != isp1362_hcd->async.prev) {
+                DBG(2, "%s: Cycling ASYNC schedule %d\n", __func__, ptd_count);
+                list_move(&isp1362_hcd->async, isp1362_hcd->async.next);
+        }
+        if (ptd_count || defer)
+                enable_atl_transfers(isp1362_hcd, defer ? 0 : ptd_count);
+
+        epq->ptd_count += ptd_count;
+        if (epq->ptd_count > epq->stat_maxptds) {
+                epq->stat_maxptds = epq->ptd_count;
+                DBG(0, "%s: max_ptds: %d\n", __func__, epq->stat_maxptds);
+        }
+}
+
+static void start_intl_transfers(struct isp1362_hcd *isp1362_hcd)
+{
+        int ptd_count = 0;
+        struct isp1362_ep_queue *epq = &isp1362_hcd->intl_queue;
+        struct isp1362_ep *ep;
+
+        if (atomic_read(&epq->finishing)) {
+                DBG(1, "%s: finish_transfers is active for %s\n", __func__, epq->name);
+                return;
+        }
+
+        list_for_each_entry(ep, &isp1362_hcd->periodic, schedule) {
+                struct urb *urb = get_urb(ep);
+                int ret;
+
+                if (!list_empty(&ep->active)) {
+                        DBG(1, "%s: Skipping active %s ep %p\n", __func__,
+                            epq->name, ep);
+                        continue;
+                }
+
+                DBG(1, "%s: Processing %s ep %p req %d\n", __func__,
+                    epq->name, ep, ep->num_req);
+                ret = submit_req(isp1362_hcd, urb, ep, epq);
+                if (ret == -ENOMEM)
+                        break;
+                else if (ret == -EOVERFLOW)
+                        continue;
+                ptd_count++;
+        }
+
+        if (ptd_count) {
+                static int last_count;
+
+                if (ptd_count != last_count) {
+                        DBG(0, "%s: ptd_count: %d\n", __func__, ptd_count);
+                        last_count = ptd_count;
+                }
+                enable_intl_transfers(isp1362_hcd);
+        }
+
+        epq->ptd_count += ptd_count;
+        if (epq->ptd_count > epq->stat_maxptds)
+                epq->stat_maxptds = epq->ptd_count;
+}
+
+static inline int next_ptd(struct isp1362_ep_queue *epq, struct isp1362_ep *ep)
+{
+        u16 ptd_offset = ep->ptd_offset;
+        int num_ptds = (ep->length + PTD_HEADER_SIZE + (epq->blk_size - 1)) / epq->blk_size;
+
+        DBG(2, "%s: PTD offset $%04x + %04x => %d * %04x -> $%04x\n", __func__, ptd_offset,
+            ep->length, num_ptds, epq->blk_size, ptd_offset + num_ptds * epq->blk_size);
+
+        ptd_offset += num_ptds * epq->blk_size;
+        if (ptd_offset < epq->buf_start + epq->buf_size)
+                return ptd_offset;
+        else
+                return -ENOMEM;
+}
+
+static void start_iso_transfers(struct isp1362_hcd *isp1362_hcd)
+{
+        int ptd_count = 0;
+        int flip = isp1362_hcd->istl_flip;
+        struct isp1362_ep_queue *epq;
+        int ptd_offset;
+        struct isp1362_ep *ep;
+        struct isp1362_ep *tmp;
+        u16 fno = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
+
+ fill2:
+        epq = &isp1362_hcd->istl_queue[flip];
+        if (atomic_read(&epq->finishing)) {
+                DBG(1, "%s: finish_transfers is active for %s\n", __func__, epq->name);
+                return;
+        }
+
+        if (!list_empty(&epq->active))
+                return;
+
+        ptd_offset = epq->buf_start;
+        list_for_each_entry_safe(ep, tmp, &isp1362_hcd->isoc, schedule) {
+                struct urb *urb = get_urb(ep);
+                s16 diff = fno - (u16)urb->start_frame;
+
+                DBG(1, "%s: Processing %s ep %p\n", __func__, epq->name, ep);
+
+                if (diff > urb->number_of_packets) {
+                        /* time frame for this URB has elapsed */
+                        finish_request(isp1362_hcd, ep, urb, -EOVERFLOW);
+                        continue;
+                } else if (diff < -1) {
+                        /* URB is not due in this frame or the next one.
+                         * Comparing with '-1' instead of '0' accounts for double
+                         * buffering in the ISP1362 which enables us to queue the PTD
+                         * one frame ahead of time
+                         */
+                } else if (diff == -1) {
+                        /* submit PTD's that are due in the next frame */
+                        prepare_ptd(isp1362_hcd, urb, ep, epq, fno);
+                        if (ptd_offset + PTD_HEADER_SIZE + ep->length >
+                            epq->buf_start + epq->buf_size) {
+                                pr_err("%s: Not enough ISO buffer space for %d byte PTD\n",
+                                    __func__, ep->length);
+                                continue;
+                        }
+                        ep->ptd_offset = ptd_offset;
+                        list_add_tail(&ep->active, &epq->active);
+
+                        ptd_offset = next_ptd(epq, ep);
+                        if (ptd_offset < 0) {
+                                pr_warning("%s: req %d No more %s PTD buffers available\n", __func__,
+                                     ep->num_req, epq->name);
+                                break;
+                        }
+                }
+        }
+        list_for_each_entry(ep, &epq->active, active) {
+                if (epq->active.next == &ep->active)
+                        ep->ptd.mps |= PTD_LAST_MSK;
+                isp1362_write_ptd(isp1362_hcd, ep, epq);
+                ptd_count++;
+        }
+
+        if (ptd_count)
+                enable_istl_transfers(isp1362_hcd, flip);
+
+        epq->ptd_count += ptd_count;
+        if (epq->ptd_count > epq->stat_maxptds)
+                epq->stat_maxptds = epq->ptd_count;
+
+        /* check, whether the second ISTL buffer may also be filled */
+        if (!(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
+              (flip ? HCBUFSTAT_ISTL0_FULL : HCBUFSTAT_ISTL1_FULL))) {
+                fno++;
+                ptd_count = 0;
+                flip = 1 - flip;
+                goto fill2;
+        }
+}
+
+static void finish_transfers(struct isp1362_hcd *isp1362_hcd, unsigned long done_map,
+                             struct isp1362_ep_queue *epq)
+{
+        struct isp1362_ep *ep;
+        struct isp1362_ep *tmp;
+
+        if (list_empty(&epq->active)) {
+                DBG(1, "%s: Nothing to do for %s queue\n", __func__, epq->name);
+                return;
+        }
+
+        DBG(1, "%s: Finishing %s transfers %08lx\n", __func__, epq->name, done_map);
+
+        atomic_inc(&epq->finishing);
+        list_for_each_entry_safe(ep, tmp, &epq->active, active) {
+                int index = ep->ptd_index;
+
+                DBG(1, "%s: Checking %s PTD[%02x] $%04x\n", __func__, epq->name,
+                    index, ep->ptd_offset);
+
+                BUG_ON(index < 0);
+                if (__test_and_clear_bit(index, &done_map)) {
+                        isp1362_read_ptd(isp1362_hcd, ep, epq);
+                        epq->free_ptd = index;
+                        BUG_ON(ep->num_ptds == 0);
+                        release_ptd_buffers(epq, ep);
+
+                        DBG(1, "%s: ep %p req %d removed from active list\n", __func__,
+                            ep, ep->num_req);
+                        if (!list_empty(&ep->remove_list)) {
+                                list_del_init(&ep->remove_list);
+                                DBG(1, "%s: ep %p removed from remove list\n", __func__, ep);
+                        }
+                        DBG(1, "%s: Postprocessing %s ep %p req %d\n", __func__, epq->name,
+                            ep, ep->num_req);
+                        postproc_ep(isp1362_hcd, ep);
+                }
+                if (!done_map)
+                        break;
+        }
+        if (done_map)
+                pr_warning("%s: done_map not clear: %08lx:%08lx\n", __func__, done_map,
+                     epq->skip_map);
+        atomic_dec(&epq->finishing);
+}
+
+static void finish_iso_transfers(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep_queue *epq)
+{
+        struct isp1362_ep *ep;
+        struct isp1362_ep *tmp;
+
+        if (list_empty(&epq->active)) {
+                DBG(1, "%s: Nothing to do for %s queue\n", __func__, epq->name);
+                return;
+        }
+
+        DBG(1, "%s: Finishing %s transfers\n", __func__, epq->name);
+
+        atomic_inc(&epq->finishing);
+        list_for_each_entry_safe(ep, tmp, &epq->active, active) {
+                DBG(1, "%s: Checking PTD $%04x\n", __func__, ep->ptd_offset);
+
+                isp1362_read_ptd(isp1362_hcd, ep, epq);
+                DBG(1, "%s: Postprocessing %s ep %p\n", __func__, epq->name, ep);
+                postproc_ep(isp1362_hcd, ep);
+        }
+        WARN_ON(epq->blk_size != 0);
+        atomic_dec(&epq->finishing);
+}
+
+static irqreturn_t isp1362_irq(struct usb_hcd *hcd)
+{
+        int handled = 0;
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        u16 irqstat;
+        u16 svc_mask;
+
+        spin_lock(&isp1362_hcd->lock);
+
+        BUG_ON(isp1362_hcd->irq_active++);
+
+        isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
+
+        irqstat = isp1362_read_reg16(isp1362_hcd, HCuPINT);
+        DBG(3, "%s: got IRQ %04x:%04x\n", __func__, irqstat, isp1362_hcd->irqenb);
+
+        /* only handle interrupts that are currently enabled */
+        irqstat &= isp1362_hcd->irqenb;
+        isp1362_write_reg16(isp1362_hcd, HCuPINT, irqstat);
+        svc_mask = irqstat;
+
+        if (irqstat & HCuPINT_SOF) {
+                isp1362_hcd->irqenb &= ~HCuPINT_SOF;
+                isp1362_hcd->irq_stat[ISP1362_INT_SOF]++;
+                handled = 1;
+                svc_mask &= ~HCuPINT_SOF;
+                DBG(3, "%s: SOF\n", __func__);
+                isp1362_hcd->fmindex = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
+                if (!list_empty(&isp1362_hcd->remove_list))
+                        finish_unlinks(isp1362_hcd);
+                if (!list_empty(&isp1362_hcd->async) && !(irqstat & HCuPINT_ATL)) {
+                        if (list_empty(&isp1362_hcd->atl_queue.active)) {
+                                start_atl_transfers(isp1362_hcd);
+                        } else {
+                                isp1362_enable_int(isp1362_hcd, HCuPINT_ATL);
+                                isp1362_write_reg32(isp1362_hcd, HCATLSKIP,
+                                                    isp1362_hcd->atl_queue.skip_map);
+                                isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
+                        }
+                }
+        }
+
+        if (irqstat & HCuPINT_ISTL0) {
+                isp1362_hcd->irq_stat[ISP1362_INT_ISTL0]++;
+                handled = 1;
+                svc_mask &= ~HCuPINT_ISTL0;
+                isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ISTL0_FULL);
+                DBG(1, "%s: ISTL0\n", __func__);
+                WARN_ON((int)!!isp1362_hcd->istl_flip);
+                WARN_ON(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
+                        HCBUFSTAT_ISTL0_ACTIVE);
+                WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
+                        HCBUFSTAT_ISTL0_DONE));
+                isp1362_hcd->irqenb &= ~HCuPINT_ISTL0;
+        }
+
+        if (irqstat & HCuPINT_ISTL1) {
+                isp1362_hcd->irq_stat[ISP1362_INT_ISTL1]++;
+                handled = 1;
+                svc_mask &= ~HCuPINT_ISTL1;
+                isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ISTL1_FULL);
+                DBG(1, "%s: ISTL1\n", __func__);
+                WARN_ON(!(int)isp1362_hcd->istl_flip);
+                WARN_ON(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
+                        HCBUFSTAT_ISTL1_ACTIVE);
+                WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
+                        HCBUFSTAT_ISTL1_DONE));
+                isp1362_hcd->irqenb &= ~HCuPINT_ISTL1;
+        }
+
+        if (irqstat & (HCuPINT_ISTL0 | HCuPINT_ISTL1)) {
+                WARN_ON((irqstat & (HCuPINT_ISTL0 | HCuPINT_ISTL1)) ==
+                        (HCuPINT_ISTL0 | HCuPINT_ISTL1));
+                finish_iso_transfers(isp1362_hcd,
+                                     &isp1362_hcd->istl_queue[isp1362_hcd->istl_flip]);
+                start_iso_transfers(isp1362_hcd);
+                isp1362_hcd->istl_flip = 1 - isp1362_hcd->istl_flip;
+        }
+
+        if (irqstat & HCuPINT_INTL) {
+                u32 done_map = isp1362_read_reg32(isp1362_hcd, HCINTLDONE);
+                u32 skip_map = isp1362_read_reg32(isp1362_hcd, HCINTLSKIP);
+                isp1362_hcd->irq_stat[ISP1362_INT_INTL]++;
+
+                DBG(2, "%s: INTL\n", __func__);
+
+                svc_mask &= ~HCuPINT_INTL;
+
+                isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, skip_map | done_map);
+                if (~(done_map | skip_map) == 0)
+                        /* All PTDs are finished, disable INTL processing entirely */
+                        isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_INTL_ACTIVE);
+
+                handled = 1;
+                WARN_ON(!done_map);
+                if (done_map) {
+                        DBG(3, "%s: INTL done_map %08x\n", __func__, done_map);
+                        finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->intl_queue);
+                        start_intl_transfers(isp1362_hcd);
+                }
+        }
+
+        if (irqstat & HCuPINT_ATL) {
+                u32 done_map = isp1362_read_reg32(isp1362_hcd, HCATLDONE);
+                u32 skip_map = isp1362_read_reg32(isp1362_hcd, HCATLSKIP);
+                isp1362_hcd->irq_stat[ISP1362_INT_ATL]++;
+
+                DBG(2, "%s: ATL\n", __func__);
+
+                svc_mask &= ~HCuPINT_ATL;
+
+                isp1362_write_reg32(isp1362_hcd, HCATLSKIP, skip_map | done_map);
+                if (~(done_map | skip_map) == 0)
+                        isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
+                if (done_map) {
+                        DBG(3, "%s: ATL done_map %08x\n", __func__, done_map);
+                        finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->atl_queue);
+                        start_atl_transfers(isp1362_hcd);
+                }
+                handled = 1;
+        }
+
+        if (irqstat & HCuPINT_OPR) {
+                u32 intstat = isp1362_read_reg32(isp1362_hcd, HCINTSTAT);
+                isp1362_hcd->irq_stat[ISP1362_INT_OPR]++;
+
+                svc_mask &= ~HCuPINT_OPR;
+                DBG(2, "%s: OPR %08x:%08x\n", __func__, intstat, isp1362_hcd->intenb);
+                intstat &= isp1362_hcd->intenb;
+                if (intstat & OHCI_INTR_UE) {
+                        pr_err("Unrecoverable error\n");
+                        /* FIXME: do here reset or cleanup or whatever */
+                }
+                if (intstat & OHCI_INTR_RHSC) {
+                        isp1362_hcd->rhstatus = isp1362_read_reg32(isp1362_hcd, HCRHSTATUS);
+                        isp1362_hcd->rhport[0] = isp1362_read_reg32(isp1362_hcd, HCRHPORT1);
+                        isp1362_hcd->rhport[1] = isp1362_read_reg32(isp1362_hcd, HCRHPORT2);
+                }
+                if (intstat & OHCI_INTR_RD) {
+                        pr_info("%s: RESUME DETECTED\n", __func__);
+                        isp1362_show_reg(isp1362_hcd, HCCONTROL);
+                        usb_hcd_resume_root_hub(hcd);
+                }
+                isp1362_write_reg32(isp1362_hcd, HCINTSTAT, intstat);
+                irqstat &= ~HCuPINT_OPR;
+                handled = 1;
+        }
+
+        if (irqstat & HCuPINT_SUSP) {
+                isp1362_hcd->irq_stat[ISP1362_INT_SUSP]++;
+                handled = 1;
+                svc_mask &= ~HCuPINT_SUSP;
+
+                pr_info("%s: SUSPEND IRQ\n", __func__);
+        }
+
+        if (irqstat & HCuPINT_CLKRDY) {
+                isp1362_hcd->irq_stat[ISP1362_INT_CLKRDY]++;
+                handled = 1;
+                isp1362_hcd->irqenb &= ~HCuPINT_CLKRDY;
+                svc_mask &= ~HCuPINT_CLKRDY;
+                pr_info("%s: CLKRDY IRQ\n", __func__);
+        }
+
+        if (svc_mask)
+                pr_err("%s: Unserviced interrupt(s) %04x\n", __func__, svc_mask);
+
+        isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
+        isp1362_hcd->irq_active--;
+        spin_unlock(&isp1362_hcd->lock);
+
+        return IRQ_RETVAL(handled);
+}
+
+/*-------------------------------------------------------------------------*/
+
+#define MAX_PERIODIC_LOAD       900     /* out of 1000 usec */
+static int balance(struct isp1362_hcd *isp1362_hcd, u16 interval, u16 load)
+{
+        int i, branch = -ENOSPC;
+
+        /* search for the least loaded schedule branch of that interval
+         * which has enough bandwidth left unreserved.
+         */
+        for (i = 0; i < interval; i++) {
+                if (branch < 0 || isp1362_hcd->load[branch] > isp1362_hcd->load[i]) {
+                        int j;
+
+                        for (j = i; j < PERIODIC_SIZE; j += interval) {
+                                if ((isp1362_hcd->load[j] + load) > MAX_PERIODIC_LOAD) {
+                                        pr_err("%s: new load %d load[%02x] %d max %d\n", __func__,
+                                            load, j, isp1362_hcd->load[j], MAX_PERIODIC_LOAD);
+                                        break;
+                                }
+                        }
+                        if (j < PERIODIC_SIZE)
+                                continue;
+                        branch = i;
+                }
+        }
+        return branch;
+}
+
+/* NB! ALL the code above this point runs with isp1362_hcd->lock
+   held, irqs off
+*/
+
+/*-------------------------------------------------------------------------*/
+
+static int isp1362_urb_enqueue(struct usb_hcd *hcd,
+                               struct urb *urb,
+                               gfp_t mem_flags)
+{
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        struct usb_device *udev = urb->dev;
+        unsigned int pipe = urb->pipe;
+        int is_out = !usb_pipein(pipe);
+        int type = usb_pipetype(pipe);
+        int epnum = usb_pipeendpoint(pipe);
+        struct usb_host_endpoint *hep = urb->ep;
+        struct isp1362_ep *ep = NULL;
+        unsigned long flags;
+        int retval = 0;
+
+        DBG(3, "%s: urb %p\n", __func__, urb);
+
+        if (type == PIPE_ISOCHRONOUS) {
+                pr_err("Isochronous transfers not supported\n");
+                return -ENOSPC;
+        }
+
+        URB_DBG("%s: FA %d ep%d%s %s: len %d %s%s\n", __func__,
+                usb_pipedevice(pipe), epnum,
+                is_out ? "out" : "in",
+                usb_pipecontrol(pipe) ? "ctrl" :
+                        usb_pipeint(pipe) ? "int" :
+                        usb_pipebulk(pipe) ? "bulk" :
+                        "iso",
+                urb->transfer_buffer_length,
+                (urb->transfer_flags & URB_ZERO_PACKET) ? "ZERO_PACKET " : "",
+                !(urb->transfer_flags & URB_SHORT_NOT_OK) ?
+                "short_ok" : "");
+
+        /* avoid all allocations within spinlocks: request or endpoint */
+        if (!hep->hcpriv) {
+                ep = kcalloc(1, sizeof *ep, mem_flags);
+                if (!ep)
+                        return -ENOMEM;
+        }
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+
+        /* don't submit to a dead or disabled port */
+        if (!((isp1362_hcd->rhport[0] | isp1362_hcd->rhport[1]) &
+              (1 << USB_PORT_FEAT_ENABLE)) ||
+            !HC_IS_RUNNING(hcd->state)) {
+                kfree(ep);
+                retval = -ENODEV;
+                goto fail_not_linked;
+        }
+
+        retval = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (retval) {
+                kfree(ep);
+                goto fail_not_linked;
+        }
+
+        if (hep->hcpriv) {
+                ep = hep->hcpriv;
+        } else {
+                INIT_LIST_HEAD(&ep->schedule);
+                INIT_LIST_HEAD(&ep->active);
+                INIT_LIST_HEAD(&ep->remove_list);
+                ep->udev = usb_get_dev(udev);
+                ep->hep = hep;
+                ep->epnum = epnum;
+                ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
+                ep->ptd_offset = -EINVAL;
+                ep->ptd_index = -EINVAL;
+                usb_settoggle(udev, epnum, is_out, 0);
+
+                if (type == PIPE_CONTROL)
+                        ep->nextpid = USB_PID_SETUP;
+                else if (is_out)
+                        ep->nextpid = USB_PID_OUT;
+                else
+                        ep->nextpid = USB_PID_IN;
+
+                switch (type) {
+                case PIPE_ISOCHRONOUS:
+                case PIPE_INTERRUPT:
+                        if (urb->interval > PERIODIC_SIZE)
+                                urb->interval = PERIODIC_SIZE;
+                        ep->interval = urb->interval;
+                        ep->branch = PERIODIC_SIZE;
+                        ep->load = usb_calc_bus_time(udev->speed, !is_out,
+                                                     (type == PIPE_ISOCHRONOUS),
+                                                     usb_maxpacket(udev, pipe, is_out)) / 1000;
+                        break;
+                }
+                hep->hcpriv = ep;
+        }
+        ep->num_req = isp1362_hcd->req_serial++;
+
+        /* maybe put endpoint into schedule */
+        switch (type) {
+        case PIPE_CONTROL:
+        case PIPE_BULK:
+                if (list_empty(&ep->schedule)) {
+                        DBG(1, "%s: Adding ep %p req %d to async schedule\n",
+                                __func__, ep, ep->num_req);
+                        list_add_tail(&ep->schedule, &isp1362_hcd->async);
+                }
+                break;
+        case PIPE_ISOCHRONOUS:
+        case PIPE_INTERRUPT:
+                urb->interval = ep->interval;
+
+                /* urb submitted for already existing EP */
+                if (ep->branch < PERIODIC_SIZE)
+                        break;
+
+                retval = balance(isp1362_hcd, ep->interval, ep->load);
+                if (retval < 0) {
+                        pr_err("%s: balance returned %d\n", __func__, retval);
+                        goto fail;
+                }
+                ep->branch = retval;
+                retval = 0;
+                isp1362_hcd->fmindex = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
+                DBG(1, "%s: Current frame %04x branch %02x start_frame %04x(%04x)\n",
+                    __func__, isp1362_hcd->fmindex, ep->branch,
+                    ((isp1362_hcd->fmindex + PERIODIC_SIZE - 1) &
+                     ~(PERIODIC_SIZE - 1)) + ep->branch,
+                    (isp1362_hcd->fmindex & (PERIODIC_SIZE - 1)) + ep->branch);
+
+                if (list_empty(&ep->schedule)) {
+                        if (type == PIPE_ISOCHRONOUS) {
+                                u16 frame = isp1362_hcd->fmindex;
+
+                                frame += max_t(u16, 8, ep->interval);
+                                frame &= ~(ep->interval - 1);
+                                frame |= ep->branch;
+                                if (frame_before(frame, isp1362_hcd->fmindex))
+                                        frame += ep->interval;
+                                urb->start_frame = frame;
+
+                                DBG(1, "%s: Adding ep %p to isoc schedule\n", __func__, ep);
+                                list_add_tail(&ep->schedule, &isp1362_hcd->isoc);
+                        } else {
+                                DBG(1, "%s: Adding ep %p to periodic schedule\n", __func__, ep);
+                                list_add_tail(&ep->schedule, &isp1362_hcd->periodic);
+                        }
+                } else
+                        DBG(1, "%s: ep %p already scheduled\n", __func__, ep);
+
+                DBG(2, "%s: load %d bandwidth %d -> %d\n", __func__,
+                    ep->load / ep->interval, isp1362_hcd->load[ep->branch],
+                    isp1362_hcd->load[ep->branch] + ep->load);
+                isp1362_hcd->load[ep->branch] += ep->load;
+        }
+
+        urb->hcpriv = hep;
+        ALIGNSTAT(isp1362_hcd, urb->transfer_buffer);
+
+        switch (type) {
+        case PIPE_CONTROL:
+        case PIPE_BULK:
+                start_atl_transfers(isp1362_hcd);
+                break;
+        case PIPE_INTERRUPT:
+                start_intl_transfers(isp1362_hcd);
+                break;
+        case PIPE_ISOCHRONOUS:
+                start_iso_transfers(isp1362_hcd);
+                break;
+        default:
+                BUG();
+        }
+ fail:
+        if (retval)
+                usb_hcd_unlink_urb_from_ep(hcd, urb);
+
+
+ fail_not_linked:
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+        if (retval)
+                DBG(0, "%s: urb %p failed with %d\n", __func__, urb, retval);
+        return retval;
+}
+
+static int isp1362_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
+{
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        struct usb_host_endpoint *hep;
+        unsigned long flags;
+        struct isp1362_ep *ep;
+        int retval = 0;
+
+        DBG(3, "%s: urb %p\n", __func__, urb);
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        retval = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (retval)
+                goto done;
+
+        hep = urb->hcpriv;
+
+        if (!hep) {
+                spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                return -EIDRM;
+        }
+
+        ep = hep->hcpriv;
+        if (ep) {
+                /* In front of queue? */
+                if (ep->hep->urb_list.next == &urb->urb_list) {
+                        if (!list_empty(&ep->active)) {
+                                DBG(1, "%s: urb %p ep %p req %d active PTD[%d] $%04x\n", __func__,
+                                    urb, ep, ep->num_req, ep->ptd_index, ep->ptd_offset);
+                                /* disable processing and queue PTD for removal */
+                                remove_ptd(isp1362_hcd, ep);
+                                urb = NULL;
+                        }
+                }
+                if (urb) {
+                        DBG(1, "%s: Finishing ep %p req %d\n", __func__, ep,
+                            ep->num_req);
+                        finish_request(isp1362_hcd, ep, urb, status);
+                } else
+                        DBG(1, "%s: urb %p active; wait4irq\n", __func__, urb);
+        } else {
+                pr_warning("%s: No EP in URB %p\n", __func__, urb);
+                retval = -EINVAL;
+        }
+done:
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+        DBG(3, "%s: exit\n", __func__);
+
+        return retval;
+}
+
+static void isp1362_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep)
+{
+        struct isp1362_ep *ep = hep->hcpriv;
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        unsigned long flags;
+
+        DBG(1, "%s: ep %p\n", __func__, ep);
+        if (!ep)
+                return;
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        if (!list_empty(&hep->urb_list)) {
+                if (!list_empty(&ep->active) && list_empty(&ep->remove_list)) {
+                        DBG(1, "%s: Removing ep %p req %d PTD[%d] $%04x\n", __func__,
+                            ep, ep->num_req, ep->ptd_index, ep->ptd_offset);
+                        remove_ptd(isp1362_hcd, ep);
+                        pr_info("%s: Waiting for Interrupt to clean up\n", __func__);
+                }
+        }
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+        /* Wait for interrupt to clear out active list */
+        while (!list_empty(&ep->active))
+                msleep(1);
+
+        DBG(1, "%s: Freeing EP %p\n", __func__, ep);
+
+        usb_put_dev(ep->udev);
+        kfree(ep);
+        hep->hcpriv = NULL;
+}
+
+static int isp1362_get_frame(struct usb_hcd *hcd)
+{
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        u32 fmnum;
+        unsigned long flags;
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        fmnum = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+        return (int)fmnum;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* Adapted from ohci-hub.c */
+static int isp1362_hub_status_data(struct usb_hcd *hcd, char *buf)
+{
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        int ports, i, changed = 0;
+        unsigned long flags;
+
+        if (!HC_IS_RUNNING(hcd->state))
+                return -ESHUTDOWN;
+
+        /* Report no status change now, if we are scheduled to be
+           called later */
+        if (timer_pending(&hcd->rh_timer))
+                return 0;
+
+        ports = isp1362_hcd->rhdesca & RH_A_NDP;
+        BUG_ON(ports > 2);
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        /* init status */
+        if (isp1362_hcd->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
+                buf[0] = changed = 1;
+        else
+                buf[0] = 0;
+
+        for (i = 0; i < ports; i++) {
+                u32 status = isp1362_hcd->rhport[i];
+
+                if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC |
+                              RH_PS_OCIC | RH_PS_PRSC)) {
+                        changed = 1;
+                        buf[0] |= 1 << (i + 1);
+                        continue;
+                }
+
+                if (!(status & RH_PS_CCS))
+                        continue;
+        }
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+        return changed;
+}
+
+static void isp1362_hub_descriptor(struct isp1362_hcd *isp1362_hcd,
+                                   struct usb_hub_descriptor *desc)
+{
+        u32 reg = isp1362_hcd->rhdesca;
+
+        DBG(3, "%s: enter\n", __func__);
+
+        desc->bDescriptorType = 0x29;
+        desc->bDescLength = 9;
+        desc->bHubContrCurrent = 0;
+        desc->bNbrPorts = reg & 0x3;
+        /* Power switching, device type, overcurrent. */
+        desc->wHubCharacteristics = cpu_to_le16((reg >> 8) & 0x1f);
+        DBG(0, "%s: hubcharacteristics = %02x\n", __func__, cpu_to_le16((reg >> 8) & 0x1f));
+        desc->bPwrOn2PwrGood = (reg >> 24) & 0xff;
+        /* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
+        desc->bitmap[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1;
+        desc->bitmap[1] = ~0;
+
+        DBG(3, "%s: exit\n", __func__);
+}
+
+/* Adapted from ohci-hub.c */
+static int isp1362_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                               u16 wIndex, char *buf, u16 wLength)
+{
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        int retval = 0;
+        unsigned long flags;
+        unsigned long t1;
+        int ports = isp1362_hcd->rhdesca & RH_A_NDP;
+        u32 tmp = 0;
+
+        switch (typeReq) {
+        case ClearHubFeature:
+                DBG(0, "ClearHubFeature: ");
+                switch (wValue) {
+                case C_HUB_OVER_CURRENT:
+                        _DBG(0, "C_HUB_OVER_CURRENT\n");
+                        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                        isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_OCIC);
+                        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                case C_HUB_LOCAL_POWER:
+                        _DBG(0, "C_HUB_LOCAL_POWER\n");
+                        break;
+                default:
+                        goto error;
+                }
+                break;
+        case SetHubFeature:
+                DBG(0, "SetHubFeature: ");
+                switch (wValue) {
+                case C_HUB_OVER_CURRENT:
+                case C_HUB_LOCAL_POWER:
+                        _DBG(0, "C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
+                        break;
+                default:
+                        goto error;
+                }
+                break;
+        case GetHubDescriptor:
+                DBG(0, "GetHubDescriptor\n");
+                isp1362_hub_descriptor(isp1362_hcd, (struct usb_hub_descriptor *)buf);
+                break;
+        case GetHubStatus:
+                DBG(0, "GetHubStatus\n");
+                put_unaligned(cpu_to_le32(0), (__le32 *) buf);
+                break;
+        case GetPortStatus:
+#ifndef VERBOSE
+                DBG(0, "GetPortStatus\n");
+#endif
+                if (!wIndex || wIndex > ports)
+                        goto error;
+                tmp = isp1362_hcd->rhport[--wIndex];
+                put_unaligned(cpu_to_le32(tmp), (__le32 *) buf);
+                break;
+        case ClearPortFeature:
+                DBG(0, "ClearPortFeature: ");
+                if (!wIndex || wIndex > ports)
+                        goto error;
+                wIndex--;
+
+                switch (wValue) {
+                case USB_PORT_FEAT_ENABLE:
+                        _DBG(0, "USB_PORT_FEAT_ENABLE\n");
+                        tmp = RH_PS_CCS;
+                        break;
+                case USB_PORT_FEAT_C_ENABLE:
+                        _DBG(0, "USB_PORT_FEAT_C_ENABLE\n");
+                        tmp = RH_PS_PESC;
+                        break;
+                case USB_PORT_FEAT_SUSPEND:
+                        _DBG(0, "USB_PORT_FEAT_SUSPEND\n");
+                        tmp = RH_PS_POCI;
+                        break;
+                case USB_PORT_FEAT_C_SUSPEND:
+                        _DBG(0, "USB_PORT_FEAT_C_SUSPEND\n");
+                        tmp = RH_PS_PSSC;
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        _DBG(0, "USB_PORT_FEAT_POWER\n");
+                        tmp = RH_PS_LSDA;
+
+                        break;
+                case USB_PORT_FEAT_C_CONNECTION:
+                        _DBG(0, "USB_PORT_FEAT_C_CONNECTION\n");
+                        tmp = RH_PS_CSC;
+                        break;
+                case USB_PORT_FEAT_C_OVER_CURRENT:
+                        _DBG(0, "USB_PORT_FEAT_C_OVER_CURRENT\n");
+                        tmp = RH_PS_OCIC;
+                        break;
+                case USB_PORT_FEAT_C_RESET:
+                        _DBG(0, "USB_PORT_FEAT_C_RESET\n");
+                        tmp = RH_PS_PRSC;
+                        break;
+                default:
+                        goto error;
+                }
+
+                spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, tmp);
+                isp1362_hcd->rhport[wIndex] =
+                        isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
+                spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                break;
+        case SetPortFeature:
+                DBG(0, "SetPortFeature: ");
+                if (!wIndex || wIndex > ports)
+                        goto error;
+                wIndex--;
+                switch (wValue) {
+                case USB_PORT_FEAT_SUSPEND:
+                        _DBG(0, "USB_PORT_FEAT_SUSPEND\n");
+#ifdef  CONFIG_USB_OTG
+                        if (ohci->hcd.self.otg_port == (wIndex + 1) &&
+                            ohci->hcd.self.b_hnp_enable) {
+                                start_hnp(ohci);
+                                break;
+                        }
+#endif
+                        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                        isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PSS);
+                        isp1362_hcd->rhport[wIndex] =
+                                isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
+                        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        _DBG(0, "USB_PORT_FEAT_POWER\n");
+                        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                        isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PPS);
+                        isp1362_hcd->rhport[wIndex] =
+                                isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
+                        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                        break;
+                case USB_PORT_FEAT_RESET:
+                        _DBG(0, "USB_PORT_FEAT_RESET\n");
+                        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+
+                        t1 = jiffies + msecs_to_jiffies(USB_RESET_WIDTH);
+                        while (time_before(jiffies, t1)) {
+                                /* spin until any current reset finishes */
+                                for (;;) {
+                                        tmp = isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
+                                        if (!(tmp & RH_PS_PRS))
+                                                break;
+                                        udelay(500);
+                                }
+                                if (!(tmp & RH_PS_CCS))
+                                        break;
+                                /* Reset lasts 10ms (claims datasheet) */
+                                isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, (RH_PS_PRS));
+
+                                spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                                msleep(10);
+                                spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                        }
+
+                        isp1362_hcd->rhport[wIndex] = isp1362_read_reg32(isp1362_hcd,
+                                                                         HCRHPORT1 + wIndex);
+                        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                        break;
+                default:
+                        goto error;
+                }
+                break;
+
+        default:
+ error:
+                /* "protocol stall" on error */
+                _DBG(0, "PROTOCOL STALL\n");
+                retval = -EPIPE;
+        }
+
+        return retval;
+}
+
+#ifdef  CONFIG_PM
+static int isp1362_bus_suspend(struct usb_hcd *hcd)
+{
+        int status = 0;
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        unsigned long flags;
+
+        if (time_before(jiffies, isp1362_hcd->next_statechange))
+                msleep(5);
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+
+        isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
+        switch (isp1362_hcd->hc_control & OHCI_CTRL_HCFS) {
+        case OHCI_USB_RESUME:
+                DBG(0, "%s: resume/suspend?\n", __func__);
+                isp1362_hcd->hc_control &= ~OHCI_CTRL_HCFS;
+                isp1362_hcd->hc_control |= OHCI_USB_RESET;
+                isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
+                /* FALL THROUGH */
+        case OHCI_USB_RESET:
+                status = -EBUSY;
+                pr_warning("%s: needs reinit!\n", __func__);
+                goto done;
+        case OHCI_USB_SUSPEND:
+                pr_warning("%s: already suspended?\n", __func__);
+                goto done;
+        }
+        DBG(0, "%s: suspend root hub\n", __func__);
+
+        /* First stop any processing */
+        hcd->state = HC_STATE_QUIESCING;
+        if (!list_empty(&isp1362_hcd->atl_queue.active) ||
+            !list_empty(&isp1362_hcd->intl_queue.active) ||
+            !list_empty(&isp1362_hcd->istl_queue[0] .active) ||
+            !list_empty(&isp1362_hcd->istl_queue[1] .active)) {
+                int limit;
+
+                isp1362_write_reg32(isp1362_hcd, HCATLSKIP, ~0);
+                isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, ~0);
+                isp1362_write_reg16(isp1362_hcd, HCBUFSTAT, 0);
+                isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
+                isp1362_write_reg32(isp1362_hcd, HCINTSTAT, OHCI_INTR_SF);
+
+                DBG(0, "%s: stopping schedules ...\n", __func__);
+                limit = 2000;
+                while (limit > 0) {
+                        udelay(250);
+                        limit -= 250;
+                        if (isp1362_read_reg32(isp1362_hcd, HCINTSTAT) & OHCI_INTR_SF)
+                                break;
+                }
+                mdelay(7);
+                if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ATL) {
+                        u32 done_map = isp1362_read_reg32(isp1362_hcd, HCATLDONE);
+                        finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->atl_queue);
+                }
+                if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_INTL) {
+                        u32 done_map = isp1362_read_reg32(isp1362_hcd, HCINTLDONE);
+                        finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->intl_queue);
+                }
+                if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ISTL0)
+                        finish_iso_transfers(isp1362_hcd, &isp1362_hcd->istl_queue[0]);
+                if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ISTL1)
+                        finish_iso_transfers(isp1362_hcd, &isp1362_hcd->istl_queue[1]);
+        }
+        DBG(0, "%s: HCINTSTAT: %08x\n", __func__,
+                    isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
+        isp1362_write_reg32(isp1362_hcd, HCINTSTAT,
+                            isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
+
+        /* Suspend hub */
+        isp1362_hcd->hc_control = OHCI_USB_SUSPEND;
+        isp1362_show_reg(isp1362_hcd, HCCONTROL);
+        isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
+        isp1362_show_reg(isp1362_hcd, HCCONTROL);
+
+#if 1
+        isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
+        if ((isp1362_hcd->hc_control & OHCI_CTRL_HCFS) != OHCI_USB_SUSPEND) {
+                pr_err("%s: controller won't suspend %08x\n", __func__,
+                    isp1362_hcd->hc_control);
+                status = -EBUSY;
+        } else
+#endif
+        {
+                /* no resumes until devices finish suspending */
+                isp1362_hcd->next_statechange = jiffies + msecs_to_jiffies(5);
+        }
+done:
+        if (status == 0) {
+                hcd->state = HC_STATE_SUSPENDED;
+                DBG(0, "%s: HCD suspended: %08x\n", __func__,
+                    isp1362_read_reg32(isp1362_hcd, HCCONTROL));
+        }
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+        return status;
+}
+
+static int isp1362_bus_resume(struct usb_hcd *hcd)
+{
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        u32 port;
+        unsigned long flags;
+        int status = -EINPROGRESS;
+
+        if (time_before(jiffies, isp1362_hcd->next_statechange))
+                msleep(5);
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
+        pr_info("%s: HCCONTROL: %08x\n", __func__, isp1362_hcd->hc_control);
+        if (hcd->state == HC_STATE_RESUMING) {
+                pr_warning("%s: duplicate resume\n", __func__);
+                status = 0;
+        } else
+                switch (isp1362_hcd->hc_control & OHCI_CTRL_HCFS) {
+                case OHCI_USB_SUSPEND:
+                        DBG(0, "%s: resume root hub\n", __func__);
+                        isp1362_hcd->hc_control &= ~OHCI_CTRL_HCFS;
+                        isp1362_hcd->hc_control |= OHCI_USB_RESUME;
+                        isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
+                        break;
+                case OHCI_USB_RESUME:
+                        /* HCFS changes sometime after INTR_RD */
+                        DBG(0, "%s: remote wakeup\n", __func__);
+                        break;
+                case OHCI_USB_OPER:
+                        DBG(0, "%s: odd resume\n", __func__);
+                        status = 0;
+                        hcd->self.root_hub->dev.power.power_state = PMSG_ON;
+                        break;
+                default:                /* RESET, we lost power */
+                        DBG(0, "%s: root hub hardware reset\n", __func__);
+                        status = -EBUSY;
+                }
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+        if (status == -EBUSY) {
+                DBG(0, "%s: Restarting HC\n", __func__);
+                isp1362_hc_stop(hcd);
+                return isp1362_hc_start(hcd);
+        }
+        if (status != -EINPROGRESS)
+                return status;
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        port = isp1362_read_reg32(isp1362_hcd, HCRHDESCA) & RH_A_NDP;
+        while (port--) {
+                u32 stat = isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + port);
+
+                /* force global, not selective, resume */
+                if (!(stat & RH_PS_PSS)) {
+                        DBG(0, "%s: Not Resuming RH port %d\n", __func__, port);
+                        continue;
+                }
+                DBG(0, "%s: Resuming RH port %d\n", __func__, port);
+                isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + port, RH_PS_POCI);
+        }
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+        /* Some controllers (lucent) need extra-long delays */
+        hcd->state = HC_STATE_RESUMING;
+        mdelay(20 /* usb 11.5.1.10 */ + 15);
+
+        isp1362_hcd->hc_control = OHCI_USB_OPER;
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        isp1362_show_reg(isp1362_hcd, HCCONTROL);
+        isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+        /* TRSMRCY */
+        msleep(10);
+
+        /* keep it alive for ~5x suspend + resume costs */
+        isp1362_hcd->next_statechange = jiffies + msecs_to_jiffies(250);
+
+        hcd->self.root_hub->dev.power.power_state = PMSG_ON;
+        hcd->state = HC_STATE_RUNNING;
+        return 0;
+}
+#else
+#define isp1362_bus_suspend     NULL
+#define isp1362_bus_resume      NULL
+#endif
+
+/*-------------------------------------------------------------------------*/
+
+#ifdef STUB_DEBUG_FILE
+
+static inline void create_debug_file(struct isp1362_hcd *isp1362_hcd)
+{
+}
+static inline void remove_debug_file(struct isp1362_hcd *isp1362_hcd)
+{
+}
+
+#else
+
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+
+static void dump_irq(struct seq_file *s, char *label, u16 mask)
+{
+        seq_printf(s, "%-15s %04x%s%s%s%s%s%s\n", label, mask,
+                   mask & HCuPINT_CLKRDY ? " clkrdy" : "",
+                   mask & HCuPINT_SUSP ? " susp" : "",
+                   mask & HCuPINT_OPR ? " opr" : "",
+                   mask & HCuPINT_EOT ? " eot" : "",
+                   mask & HCuPINT_ATL ? " atl" : "",
+                   mask & HCuPINT_SOF ? " sof" : "");
+}
+
+static void dump_int(struct seq_file *s, char *label, u32 mask)
+{
+        seq_printf(s, "%-15s %08x%s%s%s%s%s%s%s\n", label, mask,
+                   mask & OHCI_INTR_MIE ? " MIE" : "",
+                   mask & OHCI_INTR_RHSC ? " rhsc" : "",
+                   mask & OHCI_INTR_FNO ? " fno" : "",
+                   mask & OHCI_INTR_UE ? " ue" : "",
+                   mask & OHCI_INTR_RD ? " rd" : "",
+                   mask & OHCI_INTR_SF ? " sof" : "",
+                   mask & OHCI_INTR_SO ? " so" : "");
+}
+
+static void dump_ctrl(struct seq_file *s, char *label, u32 mask)
+{
+        seq_printf(s, "%-15s %08x%s%s%s\n", label, mask,
+                   mask & OHCI_CTRL_RWC ? " rwc" : "",
+                   mask & OHCI_CTRL_RWE ? " rwe" : "",
+                   ({
+                           char *hcfs;
+                           switch (mask & OHCI_CTRL_HCFS) {
+                           case OHCI_USB_OPER:
+                                   hcfs = " oper";
+                                   break;
+                           case OHCI_USB_RESET:
+                                   hcfs = " reset";
+                                   break;
+                           case OHCI_USB_RESUME:
+                                   hcfs = " resume";
+                                   break;
+                           case OHCI_USB_SUSPEND:
+                                   hcfs = " suspend";
+                                   break;
+                           default:
+                                   hcfs = " ?";
+                           }
+                           hcfs;
+                   }));
+}
+
+static void dump_regs(struct seq_file *s, struct isp1362_hcd *isp1362_hcd)
+{
+        seq_printf(s, "HCREVISION [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCREVISION),
+                   isp1362_read_reg32(isp1362_hcd, HCREVISION));
+        seq_printf(s, "HCCONTROL  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCCONTROL),
+                   isp1362_read_reg32(isp1362_hcd, HCCONTROL));
+        seq_printf(s, "HCCMDSTAT  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCCMDSTAT),
+                   isp1362_read_reg32(isp1362_hcd, HCCMDSTAT));
+        seq_printf(s, "HCINTSTAT  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTSTAT),
+                   isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
+        seq_printf(s, "HCINTENB   [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTENB),
+                   isp1362_read_reg32(isp1362_hcd, HCINTENB));
+        seq_printf(s, "HCFMINTVL  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMINTVL),
+                   isp1362_read_reg32(isp1362_hcd, HCFMINTVL));
+        seq_printf(s, "HCFMREM    [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMREM),
+                   isp1362_read_reg32(isp1362_hcd, HCFMREM));
+        seq_printf(s, "HCFMNUM    [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMNUM),
+                   isp1362_read_reg32(isp1362_hcd, HCFMNUM));
+        seq_printf(s, "HCLSTHRESH [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCLSTHRESH),
+                   isp1362_read_reg32(isp1362_hcd, HCLSTHRESH));
+        seq_printf(s, "HCRHDESCA  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHDESCA),
+                   isp1362_read_reg32(isp1362_hcd, HCRHDESCA));
+        seq_printf(s, "HCRHDESCB  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHDESCB),
+                   isp1362_read_reg32(isp1362_hcd, HCRHDESCB));
+        seq_printf(s, "HCRHSTATUS [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHSTATUS),
+                   isp1362_read_reg32(isp1362_hcd, HCRHSTATUS));
+        seq_printf(s, "HCRHPORT1  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHPORT1),
+                   isp1362_read_reg32(isp1362_hcd, HCRHPORT1));
+        seq_printf(s, "HCRHPORT2  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHPORT2),
+                   isp1362_read_reg32(isp1362_hcd, HCRHPORT2));
+        seq_printf(s, "\n");
+        seq_printf(s, "HCHWCFG    [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCHWCFG),
+                   isp1362_read_reg16(isp1362_hcd, HCHWCFG));
+        seq_printf(s, "HCDMACFG   [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCDMACFG),
+                   isp1362_read_reg16(isp1362_hcd, HCDMACFG));
+        seq_printf(s, "HCXFERCTR  [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCXFERCTR),
+                   isp1362_read_reg16(isp1362_hcd, HCXFERCTR));
+        seq_printf(s, "HCuPINT    [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCuPINT),
+                   isp1362_read_reg16(isp1362_hcd, HCuPINT));
+        seq_printf(s, "HCuPINTENB [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCuPINTENB),
+                   isp1362_read_reg16(isp1362_hcd, HCuPINTENB));
+        seq_printf(s, "HCCHIPID   [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCCHIPID),
+                   isp1362_read_reg16(isp1362_hcd, HCCHIPID));
+        seq_printf(s, "HCSCRATCH  [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCSCRATCH),
+                   isp1362_read_reg16(isp1362_hcd, HCSCRATCH));
+        seq_printf(s, "HCBUFSTAT  [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCBUFSTAT),
+                   isp1362_read_reg16(isp1362_hcd, HCBUFSTAT));
+        seq_printf(s, "HCDIRADDR  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCDIRADDR),
+                   isp1362_read_reg32(isp1362_hcd, HCDIRADDR));
+#if 0
+        seq_printf(s, "HCDIRDATA  [%02x]     %04x\n", ISP1362_REG_NO(HCDIRDATA),
+                   isp1362_read_reg16(isp1362_hcd, HCDIRDATA));
+#endif
+        seq_printf(s, "HCISTLBUFSZ[%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCISTLBUFSZ),
+                   isp1362_read_reg16(isp1362_hcd, HCISTLBUFSZ));
+        seq_printf(s, "HCISTLRATE [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCISTLRATE),
+                   isp1362_read_reg16(isp1362_hcd, HCISTLRATE));
+        seq_printf(s, "\n");
+        seq_printf(s, "HCINTLBUFSZ[%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLBUFSZ),
+                   isp1362_read_reg16(isp1362_hcd, HCINTLBUFSZ));
+        seq_printf(s, "HCINTLBLKSZ[%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLBLKSZ),
+                   isp1362_read_reg16(isp1362_hcd, HCINTLBLKSZ));
+        seq_printf(s, "HCINTLDONE [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLDONE),
+                   isp1362_read_reg32(isp1362_hcd, HCINTLDONE));
+        seq_printf(s, "HCINTLSKIP [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLSKIP),
+                   isp1362_read_reg32(isp1362_hcd, HCINTLSKIP));
+        seq_printf(s, "HCINTLLAST [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLLAST),
+                   isp1362_read_reg32(isp1362_hcd, HCINTLLAST));
+        seq_printf(s, "HCINTLCURR [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLCURR),
+                   isp1362_read_reg16(isp1362_hcd, HCINTLCURR));
+        seq_printf(s, "\n");
+        seq_printf(s, "HCATLBUFSZ [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLBUFSZ),
+                   isp1362_read_reg16(isp1362_hcd, HCATLBUFSZ));
+        seq_printf(s, "HCATLBLKSZ [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLBLKSZ),
+                   isp1362_read_reg16(isp1362_hcd, HCATLBLKSZ));
+#if 0
+        seq_printf(s, "HCATLDONE  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDONE),
+                   isp1362_read_reg32(isp1362_hcd, HCATLDONE));
+#endif
+        seq_printf(s, "HCATLSKIP  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLSKIP),
+                   isp1362_read_reg32(isp1362_hcd, HCATLSKIP));
+        seq_printf(s, "HCATLLAST  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLLAST),
+                   isp1362_read_reg32(isp1362_hcd, HCATLLAST));
+        seq_printf(s, "HCATLCURR  [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLCURR),
+                   isp1362_read_reg16(isp1362_hcd, HCATLCURR));
+        seq_printf(s, "\n");
+        seq_printf(s, "HCATLDTC   [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDTC),
+                   isp1362_read_reg16(isp1362_hcd, HCATLDTC));
+        seq_printf(s, "HCATLDTCTO [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDTCTO),
+                   isp1362_read_reg16(isp1362_hcd, HCATLDTCTO));
+}
+
+static int proc_isp1362_show(struct seq_file *s, void *unused)
+{
+        struct isp1362_hcd *isp1362_hcd = s->private;
+        struct isp1362_ep *ep;
+        int i;
+
+        seq_printf(s, "%s\n%s version %s\n",
+                   isp1362_hcd_to_hcd(isp1362_hcd)->product_desc, hcd_name, DRIVER_VERSION);
+
+        /* collect statistics to help estimate potential win for
+         * DMA engines that care about alignment (PXA)
+         */
+        seq_printf(s, "alignment:  16b/%ld 8b/%ld 4b/%ld 2b/%ld 1b/%ld\n",
+                   isp1362_hcd->stat16, isp1362_hcd->stat8, isp1362_hcd->stat4,
+                   isp1362_hcd->stat2, isp1362_hcd->stat1);
+        seq_printf(s, "max # ptds in ATL  fifo: %d\n", isp1362_hcd->atl_queue.stat_maxptds);
+        seq_printf(s, "max # ptds in INTL fifo: %d\n", isp1362_hcd->intl_queue.stat_maxptds);
+        seq_printf(s, "max # ptds in ISTL fifo: %d\n",
+                   max(isp1362_hcd->istl_queue[0] .stat_maxptds,
+                       isp1362_hcd->istl_queue[1] .stat_maxptds));
+
+        /* FIXME: don't show the following in suspended state */
+        spin_lock_irq(&isp1362_hcd->lock);
+
+        dump_irq(s, "hc_irq_enable", isp1362_read_reg16(isp1362_hcd, HCuPINTENB));
+        dump_irq(s, "hc_irq_status", isp1362_read_reg16(isp1362_hcd, HCuPINT));
+        dump_int(s, "ohci_int_enable", isp1362_read_reg32(isp1362_hcd, HCINTENB));
+        dump_int(s, "ohci_int_status", isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
+        dump_ctrl(s, "ohci_control", isp1362_read_reg32(isp1362_hcd, HCCONTROL));
+
+        for (i = 0; i < NUM_ISP1362_IRQS; i++)
+                if (isp1362_hcd->irq_stat[i])
+                        seq_printf(s, "%-15s: %d\n",
+                                   ISP1362_INT_NAME(i), isp1362_hcd->irq_stat[i]);
+
+        dump_regs(s, isp1362_hcd);
+        list_for_each_entry(ep, &isp1362_hcd->async, schedule) {
+                struct urb *urb;
+
+                seq_printf(s, "%p, ep%d%s, maxpacket %d:\n", ep, ep->epnum,
+                           ({
+                                   char *s;
+                                   switch (ep->nextpid) {
+                                   case USB_PID_IN:
+                                           s = "in";
+                                           break;
+                                   case USB_PID_OUT:
+                                           s = "out";
+                                           break;
+                                   case USB_PID_SETUP:
+                                           s = "setup";
+                                           break;
+                                   case USB_PID_ACK:
+                                           s = "status";
+                                           break;
+                                   default:
+                                           s = "?";
+                                           break;
+                                   };
+                                   s;}), ep->maxpacket) ;
+                list_for_each_entry(urb, &ep->hep->urb_list, urb_list) {
+                        seq_printf(s, "  urb%p, %d/%d\n", urb,
+                                   urb->actual_length,
+                                   urb->transfer_buffer_length);
+                }
+        }
+        if (!list_empty(&isp1362_hcd->async))
+                seq_printf(s, "\n");
+        dump_ptd_queue(&isp1362_hcd->atl_queue);
+
+        seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE);
+
+        list_for_each_entry(ep, &isp1362_hcd->periodic, schedule) {
+                seq_printf(s, "branch:%2d load:%3d PTD[%d] $%04x:\n", ep->branch,
+                           isp1362_hcd->load[ep->branch], ep->ptd_index, ep->ptd_offset);
+
+                seq_printf(s, "   %d/%p (%sdev%d ep%d%s max %d)\n",
+                           ep->interval, ep,
+                           (ep->udev->speed == USB_SPEED_FULL) ? "" : "ls ",
+                           ep->udev->devnum, ep->epnum,
+                           (ep->epnum == 0) ? "" :
+                           ((ep->nextpid == USB_PID_IN) ?
+                            "in" : "out"), ep->maxpacket);
+        }
+        dump_ptd_queue(&isp1362_hcd->intl_queue);
+
+        seq_printf(s, "ISO:\n");
+
+        list_for_each_entry(ep, &isp1362_hcd->isoc, schedule) {
+                seq_printf(s, "   %d/%p (%sdev%d ep%d%s max %d)\n",
+                           ep->interval, ep,
+                           (ep->udev->speed == USB_SPEED_FULL) ? "" : "ls ",
+                           ep->udev->devnum, ep->epnum,
+                           (ep->epnum == 0) ? "" :
+                           ((ep->nextpid == USB_PID_IN) ?
+                            "in" : "out"), ep->maxpacket);
+        }
+
+        spin_unlock_irq(&isp1362_hcd->lock);
+        seq_printf(s, "\n");
+
+        return 0;
+}
+
+static int proc_isp1362_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, proc_isp1362_show, PDE(inode)->data);
+}
+
+static const struct file_operations proc_ops = {
+        .open = proc_isp1362_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+/* expect just one isp1362_hcd per system */
+static const char proc_filename[] = "driver/isp1362";
+
+static void create_debug_file(struct isp1362_hcd *isp1362_hcd)
+{
+        struct proc_dir_entry *pde;
+
+        pde = create_proc_entry(proc_filename, 0, NULL);
+        if (pde == NULL) {
+                pr_warning("%s: Failed to create debug file '%s'\n", __func__, proc_filename);
+                return;
+        }
+
+        pde->proc_fops = &proc_ops;
+        pde->data = isp1362_hcd;
+        isp1362_hcd->pde = pde;
+}
+
+static void remove_debug_file(struct isp1362_hcd *isp1362_hcd)
+{
+        if (isp1362_hcd->pde)
+                remove_proc_entry(proc_filename, 0);
+}
+
+#endif
+
+/*-------------------------------------------------------------------------*/
+
+static void isp1362_sw_reset(struct isp1362_hcd *isp1362_hcd)
+{
+        int tmp = 20;
+        unsigned long flags;
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+
+        isp1362_write_reg16(isp1362_hcd, HCSWRES, HCSWRES_MAGIC);
+        isp1362_write_reg32(isp1362_hcd, HCCMDSTAT, OHCI_HCR);
+        while (--tmp) {
+                mdelay(1);
+                if (!(isp1362_read_reg32(isp1362_hcd, HCCMDSTAT) & OHCI_HCR))
+                        break;
+        }
+        if (!tmp)
+                pr_err("Software reset timeout\n");
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+}
+
+static int isp1362_mem_config(struct usb_hcd *hcd)
+{
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        unsigned long flags;
+        u32 total;
+        u16 istl_size = ISP1362_ISTL_BUFSIZE;
+        u16 intl_blksize = ISP1362_INTL_BLKSIZE + PTD_HEADER_SIZE;
+        u16 intl_size = ISP1362_INTL_BUFFERS * intl_blksize;
+        u16 atl_blksize = ISP1362_ATL_BLKSIZE + PTD_HEADER_SIZE;
+        u16 atl_buffers = (ISP1362_BUF_SIZE - (istl_size + intl_size)) / atl_blksize;
+        u16 atl_size;
+        int i;
+
+        WARN_ON(istl_size & 3);
+        WARN_ON(atl_blksize & 3);
+        WARN_ON(intl_blksize & 3);
+        WARN_ON(atl_blksize < PTD_HEADER_SIZE);
+        WARN_ON(intl_blksize < PTD_HEADER_SIZE);
+
+        BUG_ON((unsigned)ISP1362_INTL_BUFFERS > 32);
+        if (atl_buffers > 32)
+                atl_buffers = 32;
+        atl_size = atl_buffers * atl_blksize;
+        total = atl_size + intl_size + istl_size;
+        dev_info(hcd->self.controller, "ISP1362 Memory usage:\n");
+        dev_info(hcd->self.controller, "  ISTL:    2 * %4d:     %4d @ $%04x:$%04x\n",
+                 istl_size / 2, istl_size, 0, istl_size / 2);
+        dev_info(hcd->self.controller, "  INTL: %4d * (%3u+8):  %4d @ $%04x\n",
+                 ISP1362_INTL_BUFFERS, intl_blksize - PTD_HEADER_SIZE,
+                 intl_size, istl_size);
+        dev_info(hcd->self.controller, "  ATL : %4d * (%3u+8):  %4d @ $%04x\n",
+                 atl_buffers, atl_blksize - PTD_HEADER_SIZE,
+                 atl_size, istl_size + intl_size);
+        dev_info(hcd->self.controller, "  USED/FREE:   %4d      %4d\n", total,
+                 ISP1362_BUF_SIZE - total);
+
+        if (total > ISP1362_BUF_SIZE) {
+                dev_err(hcd->self.controller, "%s: Memory requested: %d, available %d\n",
+                        __func__, total, ISP1362_BUF_SIZE);
+                return -ENOMEM;
+        }
+
+        total = istl_size + intl_size + atl_size;
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+
+        for (i = 0; i < 2; i++) {
+                isp1362_hcd->istl_queue[i].buf_start = i * istl_size / 2,
+                isp1362_hcd->istl_queue[i].buf_size = istl_size / 2;
+                isp1362_hcd->istl_queue[i].blk_size = 4;
+                INIT_LIST_HEAD(&isp1362_hcd->istl_queue[i].active);
+                snprintf(isp1362_hcd->istl_queue[i].name,
+                         sizeof(isp1362_hcd->istl_queue[i].name), "ISTL%d", i);
+                DBG(3, "%s: %5s buf $%04x %d\n", __func__,
+                     isp1362_hcd->istl_queue[i].name,
+                     isp1362_hcd->istl_queue[i].buf_start,
+                     isp1362_hcd->istl_queue[i].buf_size);
+        }
+        isp1362_write_reg16(isp1362_hcd, HCISTLBUFSZ, istl_size / 2);
+
+        isp1362_hcd->intl_queue.buf_start = istl_size;
+        isp1362_hcd->intl_queue.buf_size = intl_size;
+        isp1362_hcd->intl_queue.buf_count = ISP1362_INTL_BUFFERS;
+        isp1362_hcd->intl_queue.blk_size = intl_blksize;
+        isp1362_hcd->intl_queue.buf_avail = isp1362_hcd->intl_queue.buf_count;
+        isp1362_hcd->intl_queue.skip_map = ~0;
+        INIT_LIST_HEAD(&isp1362_hcd->intl_queue.active);
+
+        isp1362_write_reg16(isp1362_hcd, HCINTLBUFSZ,
+                            isp1362_hcd->intl_queue.buf_size);
+        isp1362_write_reg16(isp1362_hcd, HCINTLBLKSZ,
+                            isp1362_hcd->intl_queue.blk_size - PTD_HEADER_SIZE);
+        isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, ~0);
+        isp1362_write_reg32(isp1362_hcd, HCINTLLAST,
+                            1 << (ISP1362_INTL_BUFFERS - 1));
+
+        isp1362_hcd->atl_queue.buf_start = istl_size + intl_size;
+        isp1362_hcd->atl_queue.buf_size = atl_size;
+        isp1362_hcd->atl_queue.buf_count = atl_buffers;
+        isp1362_hcd->atl_queue.blk_size = atl_blksize;
+        isp1362_hcd->atl_queue.buf_avail = isp1362_hcd->atl_queue.buf_count;
+        isp1362_hcd->atl_queue.skip_map = ~0;
+        INIT_LIST_HEAD(&isp1362_hcd->atl_queue.active);
+
+        isp1362_write_reg16(isp1362_hcd, HCATLBUFSZ,
+                            isp1362_hcd->atl_queue.buf_size);
+        isp1362_write_reg16(isp1362_hcd, HCATLBLKSZ,
+                            isp1362_hcd->atl_queue.blk_size - PTD_HEADER_SIZE);
+        isp1362_write_reg32(isp1362_hcd, HCATLSKIP, ~0);
+        isp1362_write_reg32(isp1362_hcd, HCATLLAST,
+                            1 << (atl_buffers - 1));
+
+        snprintf(isp1362_hcd->atl_queue.name,
+                 sizeof(isp1362_hcd->atl_queue.name), "ATL");
+        snprintf(isp1362_hcd->intl_queue.name,
+                 sizeof(isp1362_hcd->intl_queue.name), "INTL");
+        DBG(3, "%s: %5s buf $%04x %2d * %4d = %4d\n", __func__,
+             isp1362_hcd->intl_queue.name,
+             isp1362_hcd->intl_queue.buf_start,
+             ISP1362_INTL_BUFFERS, isp1362_hcd->intl_queue.blk_size,
+             isp1362_hcd->intl_queue.buf_size);
+        DBG(3, "%s: %5s buf $%04x %2d * %4d = %4d\n", __func__,
+             isp1362_hcd->atl_queue.name,
+             isp1362_hcd->atl_queue.buf_start,
+             atl_buffers, isp1362_hcd->atl_queue.blk_size,
+             isp1362_hcd->atl_queue.buf_size);
+
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+        return 0;
+}
+
+static int isp1362_hc_reset(struct usb_hcd *hcd)
+{
+        int ret = 0;
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        unsigned long t;
+        unsigned long timeout = 100;
+        unsigned long flags;
+        int clkrdy = 0;
+
+        pr_info("%s:\n", __func__);
+
+        if (isp1362_hcd->board && isp1362_hcd->board->reset) {
+                isp1362_hcd->board->reset(hcd->self.controller, 1);
+                msleep(20);
+                if (isp1362_hcd->board->clock)
+                        isp1362_hcd->board->clock(hcd->self.controller, 1);
+                isp1362_hcd->board->reset(hcd->self.controller, 0);
+        } else
+                isp1362_sw_reset(isp1362_hcd);
+
+        /* chip has been reset. First we need to see a clock */
+        t = jiffies + msecs_to_jiffies(timeout);
+        while (!clkrdy && time_before_eq(jiffies, t)) {
+                spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                clkrdy = isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_CLKRDY;
+                spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                if (!clkrdy)
+                        msleep(4);
+        }
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_CLKRDY);
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+        if (!clkrdy) {
+                pr_err("Clock not ready after %lums\n", timeout);
+                ret = -ENODEV;
+        }
+        return ret;
+}
+
+static void isp1362_hc_stop(struct usb_hcd *hcd)
+{
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        unsigned long flags;
+        u32 tmp;
+
+        pr_info("%s:\n", __func__);
+
+        del_timer_sync(&hcd->rh_timer);
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+
+        isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
+
+        /* Switch off power for all ports */
+        tmp = isp1362_read_reg32(isp1362_hcd, HCRHDESCA);
+        tmp &= ~(RH_A_NPS | RH_A_PSM);
+        isp1362_write_reg32(isp1362_hcd, HCRHDESCA, tmp);
+        isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPS);
+
+        /* Reset the chip */
+        if (isp1362_hcd->board && isp1362_hcd->board->reset)
+                isp1362_hcd->board->reset(hcd->self.controller, 1);
+        else
+                isp1362_sw_reset(isp1362_hcd);
+
+        if (isp1362_hcd->board && isp1362_hcd->board->clock)
+                isp1362_hcd->board->clock(hcd->self.controller, 0);
+
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+}
+
+#ifdef CHIP_BUFFER_TEST
+static int isp1362_chip_test(struct isp1362_hcd *isp1362_hcd)
+{
+        int ret = 0;
+        u16 *ref;
+        unsigned long flags;
+
+        ref = kmalloc(2 * ISP1362_BUF_SIZE, GFP_KERNEL);
+        if (ref) {
+                int offset;
+                u16 *tst = &ref[ISP1362_BUF_SIZE / 2];
+
+                for (offset = 0; offset < ISP1362_BUF_SIZE / 2; offset++) {
+                        ref[offset] = ~offset;
+                        tst[offset] = offset;
+                }
+
+                for (offset = 0; offset < 4; offset++) {
+                        int j;
+
+                        for (j = 0; j < 8; j++) {
+                                spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                                isp1362_write_buffer(isp1362_hcd, (u8 *)ref + offset, 0, j);
+                                isp1362_read_buffer(isp1362_hcd, (u8 *)tst + offset, 0, j);
+                                spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+                                if (memcmp(ref, tst, j)) {
+                                        ret = -ENODEV;
+                                        pr_err("%s: memory check with %d byte offset %d failed\n",
+                                            __func__, j, offset);
+                                        dump_data((u8 *)ref + offset, j);
+                                        dump_data((u8 *)tst + offset, j);
+                                }
+                        }
+                }
+
+                spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                isp1362_write_buffer(isp1362_hcd, ref, 0, ISP1362_BUF_SIZE);
+                isp1362_read_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
+                spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+                if (memcmp(ref, tst, ISP1362_BUF_SIZE)) {
+                        ret = -ENODEV;
+                        pr_err("%s: memory check failed\n", __func__);
+                        dump_data((u8 *)tst, ISP1362_BUF_SIZE / 2);
+                }
+
+                for (offset = 0; offset < 256; offset++) {
+                        int test_size = 0;
+
+                        yield();
+
+                        memset(tst, 0, ISP1362_BUF_SIZE);
+                        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                        isp1362_write_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
+                        isp1362_read_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
+                        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                        if (memcmp(tst, tst + (ISP1362_BUF_SIZE / (2 * sizeof(*tst))),
+                                   ISP1362_BUF_SIZE / 2)) {
+                                pr_err("%s: Failed to clear buffer\n", __func__);
+                                dump_data((u8 *)tst, ISP1362_BUF_SIZE);
+                                break;
+                        }
+                        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                        isp1362_write_buffer(isp1362_hcd, ref, offset * 2, PTD_HEADER_SIZE);
+                        isp1362_write_buffer(isp1362_hcd, ref + PTD_HEADER_SIZE / sizeof(*ref),
+                                             offset * 2 + PTD_HEADER_SIZE, test_size);
+                        isp1362_read_buffer(isp1362_hcd, tst, offset * 2,
+                                            PTD_HEADER_SIZE + test_size);
+                        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                        if (memcmp(ref, tst, PTD_HEADER_SIZE + test_size)) {
+                                dump_data(((u8 *)ref) + offset, PTD_HEADER_SIZE + test_size);
+                                dump_data((u8 *)tst, PTD_HEADER_SIZE + test_size);
+                                spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                                isp1362_read_buffer(isp1362_hcd, tst, offset * 2,
+                                                    PTD_HEADER_SIZE + test_size);
+                                spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                                if (memcmp(ref, tst, PTD_HEADER_SIZE + test_size)) {
+                                        ret = -ENODEV;
+                                        pr_err("%s: memory check with offset %02x failed\n",
+                                            __func__, offset);
+                                        break;
+                                }
+                                pr_warning("%s: memory check with offset %02x ok after second read\n",
+                                     __func__, offset);
+                        }
+                }
+                kfree(ref);
+        }
+        return ret;
+}
+#endif
+
+static int isp1362_hc_start(struct usb_hcd *hcd)
+{
+        int ret;
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        struct isp1362_platform_data *board = isp1362_hcd->board;
+        u16 hwcfg;
+        u16 chipid;
+        unsigned long flags;
+
+        pr_info("%s:\n", __func__);
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        chipid = isp1362_read_reg16(isp1362_hcd, HCCHIPID);
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+        if ((chipid & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
+                pr_err("%s: Invalid chip ID %04x\n", __func__, chipid);
+                return -ENODEV;
+        }
+
+#ifdef CHIP_BUFFER_TEST
+        ret = isp1362_chip_test(isp1362_hcd);
+        if (ret)
+                return -ENODEV;
+#endif
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        /* clear interrupt status and disable all interrupt sources */
+        isp1362_write_reg16(isp1362_hcd, HCuPINT, 0xff);
+        isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
+
+        /* HW conf */
+        hwcfg = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
+        if (board->sel15Kres)
+                hwcfg |= HCHWCFG_PULLDOWN_DS2 |
+                        ((MAX_ROOT_PORTS > 1) ? HCHWCFG_PULLDOWN_DS1 : 0);
+        if (board->clknotstop)
+                hwcfg |= HCHWCFG_CLKNOTSTOP;
+        if (board->oc_enable)
+                hwcfg |= HCHWCFG_ANALOG_OC;
+        if (board->int_act_high)
+                hwcfg |= HCHWCFG_INT_POL;
+        if (board->int_edge_triggered)
+                hwcfg |= HCHWCFG_INT_TRIGGER;
+        if (board->dreq_act_high)
+                hwcfg |= HCHWCFG_DREQ_POL;
+        if (board->dack_act_high)
+                hwcfg |= HCHWCFG_DACK_POL;
+        isp1362_write_reg16(isp1362_hcd, HCHWCFG, hwcfg);
+        isp1362_show_reg(isp1362_hcd, HCHWCFG);
+        isp1362_write_reg16(isp1362_hcd, HCDMACFG, 0);
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+        ret = isp1362_mem_config(hcd);
+        if (ret)
+                return ret;
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+
+        /* Root hub conf */
+        isp1362_hcd->rhdesca = 0;
+        if (board->no_power_switching)
+                isp1362_hcd->rhdesca |= RH_A_NPS;
+        if (board->power_switching_mode)
+                isp1362_hcd->rhdesca |= RH_A_PSM;
+        if (board->potpg)
+                isp1362_hcd->rhdesca |= (board->potpg << 24) & RH_A_POTPGT;
+        else
+                isp1362_hcd->rhdesca |= (25 << 24) & RH_A_POTPGT;
+
+        isp1362_write_reg32(isp1362_hcd, HCRHDESCA, isp1362_hcd->rhdesca & ~RH_A_OCPM);
+        isp1362_write_reg32(isp1362_hcd, HCRHDESCA, isp1362_hcd->rhdesca | RH_A_OCPM);
+        isp1362_hcd->rhdesca = isp1362_read_reg32(isp1362_hcd, HCRHDESCA);
+
+        isp1362_hcd->rhdescb = RH_B_PPCM;
+        isp1362_write_reg32(isp1362_hcd, HCRHDESCB, isp1362_hcd->rhdescb);
+        isp1362_hcd->rhdescb = isp1362_read_reg32(isp1362_hcd, HCRHDESCB);
+
+        isp1362_read_reg32(isp1362_hcd, HCFMINTVL);
+        isp1362_write_reg32(isp1362_hcd, HCFMINTVL, (FSMP(FI) << 16) | FI);
+        isp1362_write_reg32(isp1362_hcd, HCLSTHRESH, LSTHRESH);
+
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+        isp1362_hcd->hc_control = OHCI_USB_OPER;
+        hcd->state = HC_STATE_RUNNING;
+
+        spin_lock_irqsave(&isp1362_hcd->lock, flags);
+        /* Set up interrupts */
+        isp1362_hcd->intenb = OHCI_INTR_MIE | OHCI_INTR_RHSC | OHCI_INTR_UE;
+        isp1362_hcd->intenb |= OHCI_INTR_RD;
+        isp1362_hcd->irqenb = HCuPINT_OPR | HCuPINT_SUSP;
+        isp1362_write_reg32(isp1362_hcd, HCINTENB, isp1362_hcd->intenb);
+        isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
+
+        /* Go operational */
+        isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
+        /* enable global power */
+        isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPSC | RH_HS_DRWE);
+
+        spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+
+        return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static struct hc_driver isp1362_hc_driver = {
+        .description =          hcd_name,
+        .product_desc =         "ISP1362 Host Controller",
+        .hcd_priv_size =        sizeof(struct isp1362_hcd),
+
+        .irq =                  isp1362_irq,
+        .flags =                HCD_USB11 | HCD_MEMORY,
+
+        .reset =                isp1362_hc_reset,
+        .start =                isp1362_hc_start,
+        .stop =                 isp1362_hc_stop,
+
+        .urb_enqueue =          isp1362_urb_enqueue,
+        .urb_dequeue =          isp1362_urb_dequeue,
+        .endpoint_disable =     isp1362_endpoint_disable,
+
+        .get_frame_number =     isp1362_get_frame,
+
+        .hub_status_data =      isp1362_hub_status_data,
+        .hub_control =          isp1362_hub_control,
+        .bus_suspend =          isp1362_bus_suspend,
+        .bus_resume =           isp1362_bus_resume,
+};
+
+/*-------------------------------------------------------------------------*/
+
+#define resource_len(r) (((r)->end - (r)->start) + 1)
+
+static int __devexit isp1362_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        struct resource *res;
+
+        remove_debug_file(isp1362_hcd);
+        DBG(0, "%s: Removing HCD\n", __func__);
+        usb_remove_hcd(hcd);
+
+        DBG(0, "%s: Unmapping data_reg @ %08x\n", __func__,
+            (u32)isp1362_hcd->data_reg);
+        iounmap(isp1362_hcd->data_reg);
+
+        DBG(0, "%s: Unmapping addr_reg @ %08x\n", __func__,
+            (u32)isp1362_hcd->addr_reg);
+        iounmap(isp1362_hcd->addr_reg);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
+        if (res)
+                release_mem_region(res->start, resource_len(res));
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
+        if (res)
+                release_mem_region(res->start, resource_len(res));
+
+        DBG(0, "%s: put_hcd\n", __func__);
+        usb_put_hcd(hcd);
+        DBG(0, "%s: Done\n", __func__);
+
+        return 0;
+}
+
+static int __init isp1362_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct isp1362_hcd *isp1362_hcd;
+        struct resource *addr, *data;
+        void __iomem *addr_reg;
+        void __iomem *data_reg;
+        int irq;
+        int retval = 0;
+
+        /* basic sanity checks first.  board-specific init logic should
+         * have initialized this the three resources and probably board
+         * specific platform_data.  we don't probe for IRQs, and do only
+         * minimal sanity checking.
+         */
+        if (pdev->num_resources < 3) {
+                retval = -ENODEV;
+                goto err1;
+        }
+
+        data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        irq = platform_get_irq(pdev, 0);
+        if (!addr || !data || irq < 0) {
+                retval = -ENODEV;
+                goto err1;
+        }
+
+#ifdef CONFIG_USB_HCD_DMA
+        if (pdev->dev.dma_mask) {
+                struct resource *dma_res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
+
+                if (!dma_res) {
+                        retval = -ENODEV;
+                        goto err1;
+                }
+                isp1362_hcd->data_dma = dma_res->start;
+                isp1362_hcd->max_dma_size = resource_len(dma_res);
+        }
+#else
+        if (pdev->dev.dma_mask) {
+                DBG(1, "won't do DMA");
+                retval = -ENODEV;
+                goto err1;
+        }
+#endif
+
+        if (!request_mem_region(addr->start, resource_len(addr), hcd_name)) {
+                retval = -EBUSY;
+                goto err1;
+        }
+        addr_reg = ioremap(addr->start, resource_len(addr));
+        if (addr_reg == NULL) {
+                retval = -ENOMEM;
+                goto err2;
+        }
+
+        if (!request_mem_region(data->start, resource_len(data), hcd_name)) {
+                retval = -EBUSY;
+                goto err3;
+        }
+        data_reg = ioremap(data->start, resource_len(data));
+        if (data_reg == NULL) {
+                retval = -ENOMEM;
+                goto err4;
+        }
+
+        /* allocate and initialize hcd */
+        hcd = usb_create_hcd(&isp1362_hc_driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto err5;
+        }
+        hcd->rsrc_start = data->start;
+        isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        isp1362_hcd->data_reg = data_reg;
+        isp1362_hcd->addr_reg = addr_reg;
+
+        isp1362_hcd->next_statechange = jiffies;
+        spin_lock_init(&isp1362_hcd->lock);
+        INIT_LIST_HEAD(&isp1362_hcd->async);
+        INIT_LIST_HEAD(&isp1362_hcd->periodic);
+        INIT_LIST_HEAD(&isp1362_hcd->isoc);
+        INIT_LIST_HEAD(&isp1362_hcd->remove_list);
+        isp1362_hcd->board = pdev->dev.platform_data;
+#if USE_PLATFORM_DELAY
+        if (!isp1362_hcd->board->delay) {
+                dev_err(hcd->self.controller, "No platform delay function given\n");
+                retval = -ENODEV;
+                goto err6;
+        }
+#endif
+
+#ifdef CONFIG_ARM
+        if (isp1362_hcd->board)
+                set_irq_type(irq, isp1362_hcd->board->int_act_high ? IRQT_RISING : IRQT_FALLING);
+#endif
+
+        retval = usb_add_hcd(hcd, irq, IRQF_TRIGGER_LOW | IRQF_DISABLED | IRQF_SHARED);
+        if (retval != 0)
+                goto err6;
+        pr_info("%s, irq %d\n", hcd->product_desc, irq);
+
+        create_debug_file(isp1362_hcd);
+
+        return 0;
+
+ err6:
+        DBG(0, "%s: Freeing dev %08x\n", __func__, (u32)isp1362_hcd);
+        usb_put_hcd(hcd);
+ err5:
+        DBG(0, "%s: Unmapping data_reg @ %08x\n", __func__, (u32)data_reg);
+        iounmap(data_reg);
+ err4:
+        DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)data->start);
+        release_mem_region(data->start, resource_len(data));
+ err3:
+        DBG(0, "%s: Unmapping addr_reg @ %08x\n", __func__, (u32)addr_reg);
+        iounmap(addr_reg);
+ err2:
+        DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)addr->start);
+        release_mem_region(addr->start, resource_len(addr));
+ err1:
+        pr_err("%s: init error, %d\n", __func__, retval);
+
+        return retval;
+}
+
+#ifdef  CONFIG_PM
+static int isp1362_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        unsigned long flags;
+        int retval = 0;
+
+        DBG(0, "%s: Suspending device\n", __func__);
+
+        if (state.event == PM_EVENT_FREEZE) {
+                DBG(0, "%s: Suspending root hub\n", __func__);
+                retval = isp1362_bus_suspend(hcd);
+        } else {
+                DBG(0, "%s: Suspending RH ports\n", __func__);
+                spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPS);
+                spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+        }
+        if (retval == 0)
+                pdev->dev.power.power_state = state;
+        return retval;
+}
+
+static int isp1362_resume(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
+        unsigned long flags;
+
+        DBG(0, "%s: Resuming\n", __func__);
+
+        if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
+                DBG(0, "%s: Resume RH ports\n", __func__);
+                spin_lock_irqsave(&isp1362_hcd->lock, flags);
+                isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPSC);
+                spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
+                return 0;
+        }
+
+        pdev->dev.power.power_state = PMSG_ON;
+
+        return isp1362_bus_resume(isp1362_hcd_to_hcd(isp1362_hcd));
+}
+#else
+#define isp1362_suspend NULL
+#define isp1362_resume  NULL
+#endif
+
+static struct platform_driver isp1362_driver = {
+        .probe = isp1362_probe,
+        .remove = __devexit_p(isp1362_remove),
+
+        .suspend = isp1362_suspend,
+        .resume = isp1362_resume,
+        .driver = {
+                .name = (char *)hcd_name,
+                .owner = THIS_MODULE,
+        },
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int __init isp1362_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+        pr_info("driver %s, %s\n", hcd_name, DRIVER_VERSION);
+        return platform_driver_register(&isp1362_driver);
+}
+module_init(isp1362_init);
+
+static void __exit isp1362_cleanup(void)
+{
+        platform_driver_unregister(&isp1362_driver);
+}
+module_exit(isp1362_cleanup);
diff --git a/drivers/usb/host/isp1362.h b/drivers/usb/host/isp1362.h
new file mode 100644
index 000000000000..fe60f62a32f3
--- /dev/null
+++ b/drivers/usb/host/isp1362.h
@@ -0,0 +1,1079 @@
+/*
+ * ISP1362 HCD (Host Controller Driver) for USB.
+ *
+ * COPYRIGHT (C) by L. Wassmann <LW@KARO-electronics.de>
+ */
+
+/* ------------------------------------------------------------------------- */
+/*
+ * Platform specific compile time options
+ */
+#if defined(CONFIG_ARCH_KARO)
+#include <asm/arch/hardware.h>
+#include <asm/arch/pxa-regs.h>
+#include <asm/arch/karo.h>
+
+#define USE_32BIT               1
+
+
+/* These options are mutually eclusive */
+#define USE_PLATFORM_DELAY      1
+#define USE_NDELAY              0
+/*
+ * MAX_ROOT_PORTS: Number of downstream ports
+ *
+ * The chip has two USB ports, one of which can be configured as
+ * an USB device port, so the value of this constant is implementation
+ * specific.
+ */
+#define MAX_ROOT_PORTS          2
+#define DUMMY_DELAY_ACCESS do {} while (0)
+
+/* insert platform specific definitions for other machines here */
+#elif defined(CONFIG_BLACKFIN)
+
+#include <linux/io.h>
+#define USE_32BIT               0
+#define MAX_ROOT_PORTS          2
+#define USE_PLATFORM_DELAY      0
+#define USE_NDELAY              1
+
+#define DUMMY_DELAY_ACCESS \
+        do { \
+                bfin_read16(ASYNC_BANK0_BASE); \
+                bfin_read16(ASYNC_BANK0_BASE); \
+                bfin_read16(ASYNC_BANK0_BASE); \
+        } while (0)
+
+#undef insw
+#undef outsw
+
+#define insw  delayed_insw
+#define outsw  delayed_outsw
+
+static inline void delayed_outsw(unsigned int addr, void *buf, int len)
+{
+        unsigned short *bp = (unsigned short *)buf;
+        while (len--) {
+                DUMMY_DELAY_ACCESS;
+                outw(*bp++, addr);
+        }
+}
+
+static inline void delayed_insw(unsigned int addr, void *buf, int len)
+{
+        unsigned short *bp = (unsigned short *)buf;
+        while (len--) {
+                DUMMY_DELAY_ACCESS;
+                *bp++ = inw((void *)addr);
+        }
+}
+
+#else
+
+#define MAX_ROOT_PORTS          2
+
+#define USE_32BIT               0
+
+/* These options are mutually eclusive */
+#define USE_PLATFORM_DELAY      0
+#define USE_NDELAY              0
+
+#define DUMMY_DELAY_ACCESS do {} while (0)
+
+#endif
+
+
+/* ------------------------------------------------------------------------- */
+
+#define USB_RESET_WIDTH                 50
+#define MAX_XFER_SIZE                   1023
+
+/* Buffer sizes */
+#define ISP1362_BUF_SIZE                4096
+#define ISP1362_ISTL_BUFSIZE            512
+#define ISP1362_INTL_BLKSIZE            64
+#define ISP1362_INTL_BUFFERS            16
+#define ISP1362_ATL_BLKSIZE             64
+
+#define ISP1362_REG_WRITE_OFFSET        0x80
+
+#ifdef ISP1362_DEBUG
+typedef const unsigned int isp1362_reg_t;
+
+#define REG_WIDTH_16                    0x000
+#define REG_WIDTH_32                    0x100
+#define REG_WIDTH_MASK                  0x100
+#define REG_NO_MASK                     0x0ff
+
+#define REG_ACCESS_R                    0x200
+#define REG_ACCESS_W                    0x400
+#define REG_ACCESS_RW                   0x600
+#define REG_ACCESS_MASK                 0x600
+
+#define ISP1362_REG_NO(r)               ((r) & REG_NO_MASK)
+
+#define _BUG_ON(x)      BUG_ON(x)
+#define _WARN_ON(x)     WARN_ON(x)
+
+#define ISP1362_REG(name, addr, width, rw) \
+static isp1362_reg_t ISP1362_REG_##name = ((addr) | (width) | (rw))
+
+#define REG_ACCESS_TEST(r)   BUG_ON(((r) & ISP1362_REG_WRITE_OFFSET) && !((r) & REG_ACCESS_W))
+#define REG_WIDTH_TEST(r, w) BUG_ON(((r) & REG_WIDTH_MASK) != (w))
+#else
+typedef const unsigned char isp1362_reg_t;
+#define ISP1362_REG_NO(r)               (r)
+#define _BUG_ON(x)                      do {} while (0)
+#define _WARN_ON(x)                     do {} while (0)
+
+#define ISP1362_REG(name, addr, width, rw) \
+static isp1362_reg_t ISP1362_REG_##name = addr
+
+#define REG_ACCESS_TEST(r)              do {} while (0)
+#define REG_WIDTH_TEST(r, w)            do {} while (0)
+#endif
+
+/* OHCI compatible registers */
+/*
+ * Note: Some of the ISP1362 'OHCI' registers implement only
+ * a subset of the bits defined in the OHCI spec.
+ *
+ * Bitmasks for the individual bits of these registers are defined in "ohci.h"
+ */
+ISP1362_REG(HCREVISION, 0x00,   REG_WIDTH_32,   REG_ACCESS_R);
+ISP1362_REG(HCCONTROL,  0x01,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCCMDSTAT,  0x02,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCINTSTAT,  0x03,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCINTENB,   0x04,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCINTDIS,   0x05,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCFMINTVL,  0x0d,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCFMREM,    0x0e,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCFMNUM,    0x0f,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCLSTHRESH, 0x11,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCRHDESCA,  0x12,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCRHDESCB,  0x13,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCRHSTATUS, 0x14,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCRHPORT1,  0x15,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCRHPORT2,  0x16,   REG_WIDTH_32,   REG_ACCESS_RW);
+
+/* Philips ISP1362 specific registers */
+ISP1362_REG(HCHWCFG,    0x20,   REG_WIDTH_16,   REG_ACCESS_RW);
+#define HCHWCFG_DISABLE_SUSPEND (1 << 15)
+#define HCHWCFG_GLOBAL_PWRDOWN  (1 << 14)
+#define HCHWCFG_PULLDOWN_DS2    (1 << 13)
+#define HCHWCFG_PULLDOWN_DS1    (1 << 12)
+#define HCHWCFG_CLKNOTSTOP      (1 << 11)
+#define HCHWCFG_ANALOG_OC       (1 << 10)
+#define HCHWCFG_ONEINT          (1 << 9)
+#define HCHWCFG_DACK_MODE       (1 << 8)
+#define HCHWCFG_ONEDMA          (1 << 7)
+#define HCHWCFG_DACK_POL        (1 << 6)
+#define HCHWCFG_DREQ_POL        (1 << 5)
+#define HCHWCFG_DBWIDTH_MASK    (0x03 << 3)
+#define HCHWCFG_DBWIDTH(n)      (((n) << 3) & HCHWCFG_DBWIDTH_MASK)
+#define HCHWCFG_INT_POL         (1 << 2)
+#define HCHWCFG_INT_TRIGGER     (1 << 1)
+#define HCHWCFG_INT_ENABLE      (1 << 0)
+
+ISP1362_REG(HCDMACFG,   0x21,   REG_WIDTH_16,   REG_ACCESS_RW);
+#define HCDMACFG_CTR_ENABLE     (1 << 7)
+#define HCDMACFG_BURST_LEN_MASK (0x03 << 5)
+#define HCDMACFG_BURST_LEN(n)   (((n) << 5) & HCDMACFG_BURST_LEN_MASK)
+#define HCDMACFG_BURST_LEN_1    HCDMACFG_BURST_LEN(0)
+#define HCDMACFG_BURST_LEN_4    HCDMACFG_BURST_LEN(1)
+#define HCDMACFG_BURST_LEN_8    HCDMACFG_BURST_LEN(2)
+#define HCDMACFG_DMA_ENABLE     (1 << 4)
+#define HCDMACFG_BUF_TYPE_MASK  (0x07 << 1)
+#define HCDMACFG_BUF_TYPE(n)    (((n) << 1) & HCDMACFG_BUF_TYPE_MASK)
+#define HCDMACFG_BUF_ISTL0      HCDMACFG_BUF_TYPE(0)
+#define HCDMACFG_BUF_ISTL1      HCDMACFG_BUF_TYPE(1)
+#define HCDMACFG_BUF_INTL       HCDMACFG_BUF_TYPE(2)
+#define HCDMACFG_BUF_ATL        HCDMACFG_BUF_TYPE(3)
+#define HCDMACFG_BUF_DIRECT     HCDMACFG_BUF_TYPE(4)
+#define HCDMACFG_DMA_RW_SELECT  (1 << 0)
+
+ISP1362_REG(HCXFERCTR,  0x22,   REG_WIDTH_16,   REG_ACCESS_RW);
+
+ISP1362_REG(HCuPINT,    0x24,   REG_WIDTH_16,   REG_ACCESS_RW);
+#define HCuPINT_SOF             (1 << 0)
+#define HCuPINT_ISTL0           (1 << 1)
+#define HCuPINT_ISTL1           (1 << 2)
+#define HCuPINT_EOT             (1 << 3)
+#define HCuPINT_OPR             (1 << 4)
+#define HCuPINT_SUSP            (1 << 5)
+#define HCuPINT_CLKRDY          (1 << 6)
+#define HCuPINT_INTL            (1 << 7)
+#define HCuPINT_ATL             (1 << 8)
+#define HCuPINT_OTG             (1 << 9)
+
+ISP1362_REG(HCuPINTENB, 0x25,   REG_WIDTH_16,   REG_ACCESS_RW);
+/* same bit definitions apply as for HCuPINT */
+
+ISP1362_REG(HCCHIPID,   0x27,   REG_WIDTH_16,   REG_ACCESS_R);
+#define HCCHIPID_MASK           0xff00
+#define HCCHIPID_MAGIC          0x3600
+
+ISP1362_REG(HCSCRATCH,  0x28,   REG_WIDTH_16,   REG_ACCESS_RW);
+
+ISP1362_REG(HCSWRES,    0x29,   REG_WIDTH_16,   REG_ACCESS_W);
+#define HCSWRES_MAGIC           0x00f6
+
+ISP1362_REG(HCBUFSTAT,  0x2c,   REG_WIDTH_16,   REG_ACCESS_RW);
+#define HCBUFSTAT_ISTL0_FULL    (1 << 0)
+#define HCBUFSTAT_ISTL1_FULL    (1 << 1)
+#define HCBUFSTAT_INTL_ACTIVE   (1 << 2)
+#define HCBUFSTAT_ATL_ACTIVE    (1 << 3)
+#define HCBUFSTAT_RESET_HWPP    (1 << 4)
+#define HCBUFSTAT_ISTL0_ACTIVE  (1 << 5)
+#define HCBUFSTAT_ISTL1_ACTIVE  (1 << 6)
+#define HCBUFSTAT_ISTL0_DONE    (1 << 8)
+#define HCBUFSTAT_ISTL1_DONE    (1 << 9)
+#define HCBUFSTAT_PAIRED_PTDPP  (1 << 10)
+
+ISP1362_REG(HCDIRADDR,  0x32,   REG_WIDTH_32,   REG_ACCESS_RW);
+#define HCDIRADDR_ADDR_MASK     0x0000ffff
+#define HCDIRADDR_ADDR(n)       (((n) << 0) & HCDIRADDR_ADDR_MASK)
+#define HCDIRADDR_COUNT_MASK    0xffff0000
+#define HCDIRADDR_COUNT(n)      (((n) << 16) & HCDIRADDR_COUNT_MASK)
+ISP1362_REG(HCDIRDATA,  0x45,   REG_WIDTH_16,   REG_ACCESS_RW);
+
+ISP1362_REG(HCISTLBUFSZ, 0x30,  REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCISTL0PORT, 0x40,  REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCISTL1PORT, 0x42,  REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCISTLRATE, 0x47,   REG_WIDTH_16,   REG_ACCESS_RW);
+
+ISP1362_REG(HCINTLBUFSZ, 0x33,  REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCINTLPORT, 0x43,   REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCINTLBLKSZ, 0x53,  REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCINTLDONE, 0x17,   REG_WIDTH_32,   REG_ACCESS_R);
+ISP1362_REG(HCINTLSKIP, 0x18,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCINTLLAST, 0x19,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCINTLCURR, 0x1a,   REG_WIDTH_16,   REG_ACCESS_R);
+
+ISP1362_REG(HCATLBUFSZ, 0x34,   REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCATLPORT,  0x44,   REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCATLBLKSZ, 0x54,   REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCATLDONE,  0x1b,   REG_WIDTH_32,   REG_ACCESS_R);
+ISP1362_REG(HCATLSKIP,  0x1c,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCATLLAST,  0x1d,   REG_WIDTH_32,   REG_ACCESS_RW);
+ISP1362_REG(HCATLCURR,  0x1e,   REG_WIDTH_16,   REG_ACCESS_R);
+
+ISP1362_REG(HCATLDTC,   0x51,   REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(HCATLDTCTO, 0x52,   REG_WIDTH_16,   REG_ACCESS_RW);
+
+
+ISP1362_REG(OTGCONTROL, 0x62,   REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(OTGSTATUS,  0x67,   REG_WIDTH_16,   REG_ACCESS_R);
+ISP1362_REG(OTGINT,     0x68,   REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(OTGINTENB,  0x69,   REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(OTGTIMER,   0x6A,   REG_WIDTH_16,   REG_ACCESS_RW);
+ISP1362_REG(OTGALTTMR,  0x6C,   REG_WIDTH_16,   REG_ACCESS_RW);
+
+/* Philips transfer descriptor, cpu-endian */
+struct ptd {
+        u16 count;
+#define PTD_COUNT_MSK   (0x3ff << 0)
+#define PTD_TOGGLE_MSK  (1 << 10)
+#define PTD_ACTIVE_MSK  (1 << 11)
+#define PTD_CC_MSK      (0xf << 12)
+        u16 mps;
+#define PTD_MPS_MSK     (0x3ff << 0)
+#define PTD_SPD_MSK     (1 << 10)
+#define PTD_LAST_MSK    (1 << 11)
+#define PTD_EP_MSK      (0xf << 12)
+        u16 len;
+#define PTD_LEN_MSK     (0x3ff << 0)
+#define PTD_DIR_MSK     (3 << 10)
+#define PTD_DIR_SETUP   (0)
+#define PTD_DIR_OUT     (1)
+#define PTD_DIR_IN      (2)
+        u16 faddr;
+#define PTD_FA_MSK      (0x7f << 0)
+/* PTD Byte 7: [StartingFrame (if ISO PTD) | StartingFrame[0..4], PollingRate[0..2] (if INT PTD)] */
+#define PTD_SF_ISO_MSK  (0xff << 8)
+#define PTD_SF_INT_MSK  (0x1f << 8)
+#define PTD_PR_MSK      (0x07 << 13)
+} __attribute__ ((packed, aligned(2)));
+#define PTD_HEADER_SIZE sizeof(struct ptd)
+
+/* ------------------------------------------------------------------------- */
+/* Copied from ohci.h: */
+/*
+ * Hardware transfer status codes -- CC from PTD
+ */
+#define PTD_CC_NOERROR      0x00
+#define PTD_CC_CRC          0x01
+#define PTD_CC_BITSTUFFING  0x02
+#define PTD_CC_DATATOGGLEM  0x03
+#define PTD_CC_STALL        0x04
+#define PTD_DEVNOTRESP      0x05
+#define PTD_PIDCHECKFAIL    0x06
+#define PTD_UNEXPECTEDPID   0x07
+#define PTD_DATAOVERRUN     0x08
+#define PTD_DATAUNDERRUN    0x09
+    /* 0x0A, 0x0B reserved for hardware */
+#define PTD_BUFFEROVERRUN   0x0C
+#define PTD_BUFFERUNDERRUN  0x0D
+    /* 0x0E, 0x0F reserved for HCD */
+#define PTD_NOTACCESSED     0x0F
+
+
+/* map OHCI TD status codes (CC) to errno values */
+static const int cc_to_error[16] = {
+        /* No  Error  */               0,
+        /* CRC Error  */               -EILSEQ,
+        /* Bit Stuff  */               -EPROTO,
+        /* Data Togg  */               -EILSEQ,
+        /* Stall      */               -EPIPE,
+        /* DevNotResp */               -ETIMEDOUT,
+        /* PIDCheck   */               -EPROTO,
+        /* UnExpPID   */               -EPROTO,
+        /* DataOver   */               -EOVERFLOW,
+        /* DataUnder  */               -EREMOTEIO,
+        /* (for hw)   */               -EIO,
+        /* (for hw)   */               -EIO,
+        /* BufferOver */               -ECOMM,
+        /* BuffUnder  */               -ENOSR,
+        /* (for HCD)  */               -EALREADY,
+        /* (for HCD)  */               -EALREADY
+};
+
+
+/*
+ * HcControl (control) register masks
+ */
+#define OHCI_CTRL_HCFS  (3 << 6)        /* host controller functional state */
+#define OHCI_CTRL_RWC   (1 << 9)        /* remote wakeup connected */
+#define OHCI_CTRL_RWE   (1 << 10)       /* remote wakeup enable */
+
+/* pre-shifted values for HCFS */
+#       define OHCI_USB_RESET   (0 << 6)
+#       define OHCI_USB_RESUME  (1 << 6)
+#       define OHCI_USB_OPER    (2 << 6)
+#       define OHCI_USB_SUSPEND (3 << 6)
+
+/*
+ * HcCommandStatus (cmdstatus) register masks
+ */
+#define OHCI_HCR        (1 << 0)        /* host controller reset */
+#define OHCI_SOC        (3 << 16)       /* scheduling overrun count */
+
+/*
+ * masks used with interrupt registers:
+ * HcInterruptStatus (intrstatus)
+ * HcInterruptEnable (intrenable)
+ * HcInterruptDisable (intrdisable)
+ */
+#define OHCI_INTR_SO    (1 << 0)        /* scheduling overrun */
+#define OHCI_INTR_WDH   (1 << 1)        /* writeback of done_head */
+#define OHCI_INTR_SF    (1 << 2)        /* start frame */
+#define OHCI_INTR_RD    (1 << 3)        /* resume detect */
+#define OHCI_INTR_UE    (1 << 4)        /* unrecoverable error */
+#define OHCI_INTR_FNO   (1 << 5)        /* frame number overflow */
+#define OHCI_INTR_RHSC  (1 << 6)        /* root hub status change */
+#define OHCI_INTR_OC    (1 << 30)       /* ownership change */
+#define OHCI_INTR_MIE   (1 << 31)       /* master interrupt enable */
+
+/* roothub.portstatus [i] bits */
+#define RH_PS_CCS            0x00000001         /* current connect status */
+#define RH_PS_PES            0x00000002         /* port enable status*/
+#define RH_PS_PSS            0x00000004         /* port suspend status */
+#define RH_PS_POCI           0x00000008         /* port over current indicator */
+#define RH_PS_PRS            0x00000010         /* port reset status */
+#define RH_PS_PPS            0x00000100         /* port power status */
+#define RH_PS_LSDA           0x00000200         /* low speed device attached */
+#define RH_PS_CSC            0x00010000         /* connect status change */
+#define RH_PS_PESC           0x00020000         /* port enable status change */
+#define RH_PS_PSSC           0x00040000         /* port suspend status change */
+#define RH_PS_OCIC           0x00080000         /* over current indicator change */
+#define RH_PS_PRSC           0x00100000         /* port reset status change */
+
+/* roothub.status bits */
+#define RH_HS_LPS            0x00000001         /* local power status */
+#define RH_HS_OCI            0x00000002         /* over current indicator */
+#define RH_HS_DRWE           0x00008000         /* device remote wakeup enable */
+#define RH_HS_LPSC           0x00010000         /* local power status change */
+#define RH_HS_OCIC           0x00020000         /* over current indicator change */
+#define RH_HS_CRWE           0x80000000         /* clear remote wakeup enable */
+
+/* roothub.b masks */
+#define RH_B_DR         0x0000ffff              /* device removable flags */
+#define RH_B_PPCM       0xffff0000              /* port power control mask */
+
+/* roothub.a masks */
+#define RH_A_NDP        (0xff << 0)             /* number of downstream ports */
+#define RH_A_PSM        (1 << 8)                /* power switching mode */
+#define RH_A_NPS        (1 << 9)                /* no power switching */
+#define RH_A_DT         (1 << 10)               /* device type (mbz) */
+#define RH_A_OCPM       (1 << 11)               /* over current protection mode */
+#define RH_A_NOCP       (1 << 12)               /* no over current protection */
+#define RH_A_POTPGT     (0xff << 24)            /* power on to power good time */
+
+#define FI                      0x2edf          /* 12000 bits per frame (-1) */
+#define FSMP(fi)                (0x7fff & ((6 * ((fi) - 210)) / 7))
+#define LSTHRESH                0x628           /* lowspeed bit threshold */
+
+/* ------------------------------------------------------------------------- */
+
+/* PTD accessor macros. */
+#define PTD_GET_COUNT(p)        (((p)->count & PTD_COUNT_MSK) >> 0)
+#define PTD_COUNT(v)            (((v) << 0) & PTD_COUNT_MSK)
+#define PTD_GET_TOGGLE(p)       (((p)->count & PTD_TOGGLE_MSK) >> 10)
+#define PTD_TOGGLE(v)           (((v) << 10) & PTD_TOGGLE_MSK)
+#define PTD_GET_ACTIVE(p)       (((p)->count & PTD_ACTIVE_MSK) >> 11)
+#define PTD_ACTIVE(v)           (((v) << 11) & PTD_ACTIVE_MSK)
+#define PTD_GET_CC(p)           (((p)->count & PTD_CC_MSK) >> 12)
+#define PTD_CC(v)               (((v) << 12) & PTD_CC_MSK)
+#define PTD_GET_MPS(p)          (((p)->mps & PTD_MPS_MSK) >> 0)
+#define PTD_MPS(v)              (((v) << 0) & PTD_MPS_MSK)
+#define PTD_GET_SPD(p)          (((p)->mps & PTD_SPD_MSK) >> 10)
+#define PTD_SPD(v)              (((v) << 10) & PTD_SPD_MSK)
+#define PTD_GET_LAST(p)         (((p)->mps & PTD_LAST_MSK) >> 11)
+#define PTD_LAST(v)             (((v) << 11) & PTD_LAST_MSK)
+#define PTD_GET_EP(p)           (((p)->mps & PTD_EP_MSK) >> 12)
+#define PTD_EP(v)               (((v) << 12) & PTD_EP_MSK)
+#define PTD_GET_LEN(p)          (((p)->len & PTD_LEN_MSK) >> 0)
+#define PTD_LEN(v)              (((v) << 0) & PTD_LEN_MSK)
+#define PTD_GET_DIR(p)          (((p)->len & PTD_DIR_MSK) >> 10)
+#define PTD_DIR(v)              (((v) << 10) & PTD_DIR_MSK)
+#define PTD_GET_FA(p)           (((p)->faddr & PTD_FA_MSK) >> 0)
+#define PTD_FA(v)               (((v) << 0) & PTD_FA_MSK)
+#define PTD_GET_SF_INT(p)       (((p)->faddr & PTD_SF_INT_MSK) >> 8)
+#define PTD_SF_INT(v)           (((v) << 8) & PTD_SF_INT_MSK)
+#define PTD_GET_SF_ISO(p)       (((p)->faddr & PTD_SF_ISO_MSK) >> 8)
+#define PTD_SF_ISO(v)           (((v) << 8) & PTD_SF_ISO_MSK)
+#define PTD_GET_PR(p)           (((p)->faddr & PTD_PR_MSK) >> 13)
+#define PTD_PR(v)               (((v) << 13) & PTD_PR_MSK)
+
+#define LOG2_PERIODIC_SIZE      5       /* arbitrary; this matches OHCI */
+#define PERIODIC_SIZE           (1 << LOG2_PERIODIC_SIZE)
+
+struct isp1362_ep {
+        struct usb_host_endpoint *hep;
+        struct usb_device       *udev;
+
+        /* philips transfer descriptor */
+        struct ptd              ptd;
+
+        u8                      maxpacket;
+        u8                      epnum;
+        u8                      nextpid;
+        u16                     error_count;
+        u16                     length;         /* of current packet */
+        s16                     ptd_offset;     /* buffer offset in ISP1362 where
+                                                   PTD has been stored
+                                                   (for access thru HCDIRDATA) */
+        int                     ptd_index;
+        int num_ptds;
+        void                    *data;          /* to databuf */
+        /* queue of active EPs (the ones transmitted to the chip) */
+        struct list_head        active;
+
+        /* periodic schedule */
+        u8                      branch;
+        u16                     interval;
+        u16                     load;
+        u16                     last_iso;
+
+        /* async schedule */
+        struct list_head        schedule;       /* list of all EPs that need processing */
+        struct list_head        remove_list;
+        int                     num_req;
+};
+
+struct isp1362_ep_queue {
+        struct list_head        active;         /* list of PTDs currently processed by HC */
+        atomic_t                finishing;
+        unsigned long           buf_map;
+        unsigned long           skip_map;
+        int                     free_ptd;
+        u16                     buf_start;
+        u16                     buf_size;
+        u16                     blk_size;       /* PTD buffer block size for ATL and INTL */
+        u8                      buf_count;
+        u8                      buf_avail;
+        char                    name[16];
+
+        /* for statistical tracking */
+        u8                      stat_maxptds;   /* Max # of ptds seen simultaneously in fifo */
+        u8                      ptd_count;      /* number of ptds submitted to this queue */
+};
+
+struct isp1362_hcd {
+        spinlock_t              lock;
+        void __iomem            *addr_reg;
+        void __iomem            *data_reg;
+
+        struct isp1362_platform_data *board;
+
+        struct proc_dir_entry   *pde;
+        unsigned long           stat1, stat2, stat4, stat8, stat16;
+
+        /* HC registers */
+        u32                     intenb;         /* "OHCI" interrupts */
+        u16                     irqenb;         /* uP interrupts */
+
+        /* Root hub registers */
+        u32                     rhdesca;
+        u32                     rhdescb;
+        u32                     rhstatus;
+        u32                     rhport[MAX_ROOT_PORTS];
+        unsigned long           next_statechange;
+
+        /* HC control reg shadow copy */
+        u32                     hc_control;
+
+        /* async schedule: control, bulk */
+        struct list_head        async;
+
+        /* periodic schedule: int */
+        u16                     load[PERIODIC_SIZE];
+        struct list_head        periodic;
+        u16                     fmindex;
+
+        /* periodic schedule: isochronous */
+        struct list_head        isoc;
+        int                     istl_flip:1;
+        int                     irq_active:1;
+
+        /* Schedules for the current frame */
+        struct isp1362_ep_queue atl_queue;
+        struct isp1362_ep_queue intl_queue;
+        struct isp1362_ep_queue istl_queue[2];
+
+        /* list of PTDs retrieved from HC */
+        struct list_head        remove_list;
+        enum {
+                ISP1362_INT_SOF,
+                ISP1362_INT_ISTL0,
+                ISP1362_INT_ISTL1,
+                ISP1362_INT_EOT,
+                ISP1362_INT_OPR,
+                ISP1362_INT_SUSP,
+                ISP1362_INT_CLKRDY,
+                ISP1362_INT_INTL,
+                ISP1362_INT_ATL,
+                ISP1362_INT_OTG,
+                NUM_ISP1362_IRQS
+        } IRQ_NAMES;
+        unsigned int            irq_stat[NUM_ISP1362_IRQS];
+        int                     req_serial;
+};
+
+static inline const char *ISP1362_INT_NAME(int n)
+{
+        switch (n) {
+        case ISP1362_INT_SOF:    return "SOF";
+        case ISP1362_INT_ISTL0:  return "ISTL0";
+        case ISP1362_INT_ISTL1:  return "ISTL1";
+        case ISP1362_INT_EOT:    return "EOT";
+        case ISP1362_INT_OPR:    return "OPR";
+        case ISP1362_INT_SUSP:   return "SUSP";
+        case ISP1362_INT_CLKRDY: return "CLKRDY";
+        case ISP1362_INT_INTL:   return "INTL";
+        case ISP1362_INT_ATL:    return "ATL";
+        case ISP1362_INT_OTG:    return "OTG";
+        default:                 return "unknown";
+        }
+}
+
+static inline void ALIGNSTAT(struct isp1362_hcd *isp1362_hcd, void *ptr)
+{
+        unsigned p = (unsigned)ptr;
+        if (!(p & 0xf))
+                isp1362_hcd->stat16++;
+        else if (!(p & 0x7))
+                isp1362_hcd->stat8++;
+        else if (!(p & 0x3))
+                isp1362_hcd->stat4++;
+        else if (!(p & 0x1))
+                isp1362_hcd->stat2++;
+        else
+                isp1362_hcd->stat1++;
+}
+
+static inline struct isp1362_hcd *hcd_to_isp1362_hcd(struct usb_hcd *hcd)
+{
+        return (struct isp1362_hcd *) (hcd->hcd_priv);
+}
+
+static inline struct usb_hcd *isp1362_hcd_to_hcd(struct isp1362_hcd *isp1362_hcd)
+{
+        return container_of((void *)isp1362_hcd, struct usb_hcd, hcd_priv);
+}
+
+#define frame_before(f1, f2)    ((s16)((u16)f1 - (u16)f2) < 0)
+
+/*
+ * ISP1362 HW Interface
+ */
+
+#ifdef ISP1362_DEBUG
+#define DBG(level, fmt...) \
+        do { \
+                if (dbg_level > level) \
+                        pr_debug(fmt); \
+        } while (0)
+#define _DBG(level, fmt...)     \
+        do { \
+                if (dbg_level > level) \
+                        printk(fmt); \
+        } while (0)
+#else
+#define DBG(fmt...)             do {} while (0)
+#define _DBG DBG
+#endif
+
+#ifdef VERBOSE
+#    define VDBG(fmt...)        DBG(3, fmt)
+#else
+#    define VDBG(fmt...)        do {} while (0)
+#endif
+
+#ifdef REGISTERS
+#    define RDBG(fmt...)        DBG(1, fmt)
+#else
+#    define RDBG(fmt...)        do {} while (0)
+#endif
+
+#ifdef URB_TRACE
+#define URB_DBG(fmt...)         DBG(0, fmt)
+#else
+#define URB_DBG(fmt...)         do {} while (0)
+#endif
+
+
+#if USE_PLATFORM_DELAY
+#if USE_NDELAY
+#error USE_PLATFORM_DELAY and USE_NDELAY defined simultaneously.
+#endif
+#define isp1362_delay(h, d)     (h)->board->delay(isp1362_hcd_to_hcd(h)->self.controller, d)
+#elif USE_NDELAY
+#define isp1362_delay(h, d)     ndelay(d)
+#else
+#define isp1362_delay(h, d)     do {} while (0)
+#endif
+
+#define get_urb(ep) ({                                                  \
+        BUG_ON(list_empty(&ep->hep->urb_list));                         \
+        container_of(ep->hep->urb_list.next, struct urb, urb_list);     \
+})
+
+/* basic access functions for ISP1362 chip registers */
+/* NOTE: The contents of the address pointer register cannot be read back! The driver must ensure,
+ * that all register accesses are performed with interrupts disabled, since the interrupt
+ * handler has no way of restoring the previous state.
+ */
+static void isp1362_write_addr(struct isp1362_hcd *isp1362_hcd, isp1362_reg_t reg)
+{
+        /*_BUG_ON((reg & ISP1362_REG_WRITE_OFFSET) && !(reg & REG_ACCESS_W));*/
+        REG_ACCESS_TEST(reg);
+        _BUG_ON(!irqs_disabled());
+        DUMMY_DELAY_ACCESS;
+        writew(ISP1362_REG_NO(reg), isp1362_hcd->addr_reg);
+        DUMMY_DELAY_ACCESS;
+        isp1362_delay(isp1362_hcd, 1);
+}
+
+static void isp1362_write_data16(struct isp1362_hcd *isp1362_hcd, u16 val)
+{
+        _BUG_ON(!irqs_disabled());
+        DUMMY_DELAY_ACCESS;
+        writew(val, isp1362_hcd->data_reg);
+}
+
+static u16 isp1362_read_data16(struct isp1362_hcd *isp1362_hcd)
+{
+        u16 val;
+
+        _BUG_ON(!irqs_disabled());
+        DUMMY_DELAY_ACCESS;
+        val = readw(isp1362_hcd->data_reg);
+
+        return val;
+}
+
+static void isp1362_write_data32(struct isp1362_hcd *isp1362_hcd, u32 val)
+{
+        _BUG_ON(!irqs_disabled());
+#if USE_32BIT
+        DUMMY_DELAY_ACCESS;
+        writel(val, isp1362_hcd->data_reg);
+#else
+        DUMMY_DELAY_ACCESS;
+        writew((u16)val, isp1362_hcd->data_reg);
+        DUMMY_DELAY_ACCESS;
+        writew(val >> 16, isp1362_hcd->data_reg);
+#endif
+}
+
+static u32 isp1362_read_data32(struct isp1362_hcd *isp1362_hcd)
+{
+        u32 val;
+
+        _BUG_ON(!irqs_disabled());
+#if USE_32BIT
+        DUMMY_DELAY_ACCESS;
+        val = readl(isp1362_hcd->data_reg);
+#else
+        DUMMY_DELAY_ACCESS;
+        val = (u32)readw(isp1362_hcd->data_reg);
+        DUMMY_DELAY_ACCESS;
+        val |= (u32)readw(isp1362_hcd->data_reg) << 16;
+#endif
+        return val;
+}
+
+/* use readsw/writesw to access the fifo whenever possible */
+/* assume HCDIRDATA or XFERCTR & addr_reg have been set up */
+static void isp1362_read_fifo(struct isp1362_hcd *isp1362_hcd, void *buf, u16 len)
+{
+        u8 *dp = buf;
+        u16 data;
+
+        if (!len)
+                return;
+
+        _BUG_ON(!irqs_disabled());
+
+        RDBG("%s: Reading %d byte from fifo to mem @ %p\n", __func__, len, buf);
+#if USE_32BIT
+        if (len >= 4) {
+                RDBG("%s: Using readsl for %d dwords\n", __func__, len >> 2);
+                readsl(isp1362_hcd->data_reg, dp, len >> 2);
+                dp += len & ~3;
+                len &= 3;
+        }
+#endif
+        if (len >= 2) {
+                RDBG("%s: Using readsw for %d words\n", __func__, len >> 1);
+                insw((unsigned long)isp1362_hcd->data_reg, dp, len >> 1);
+                dp += len & ~1;
+                len &= 1;
+        }
+
+        BUG_ON(len & ~1);
+        if (len > 0) {
+                data = isp1362_read_data16(isp1362_hcd);
+                RDBG("%s: Reading trailing byte %02x to mem @ %08x\n", __func__,
+                     (u8)data, (u32)dp);
+                *dp = (u8)data;
+        }
+}
+
+static void isp1362_write_fifo(struct isp1362_hcd *isp1362_hcd, void *buf, u16 len)
+{
+        u8 *dp = buf;
+        u16 data;
+
+        if (!len)
+                return;
+
+        if ((unsigned)dp & 0x1) {
+                /* not aligned */
+                for (; len > 1; len -= 2) {
+                        data = *dp++;
+                        data |= *dp++ << 8;
+                        isp1362_write_data16(isp1362_hcd, data);
+                }
+                if (len)
+                        isp1362_write_data16(isp1362_hcd, *dp);
+                return;
+        }
+
+        _BUG_ON(!irqs_disabled());
+
+        RDBG("%s: Writing %d byte to fifo from memory @%p\n", __func__, len, buf);
+#if USE_32BIT
+        if (len >= 4) {
+                RDBG("%s: Using writesl for %d dwords\n", __func__, len >> 2);
+                writesl(isp1362_hcd->data_reg, dp, len >> 2);
+                dp += len & ~3;
+                len &= 3;
+        }
+#endif
+        if (len >= 2) {
+                RDBG("%s: Using writesw for %d words\n", __func__, len >> 1);
+                outsw((unsigned long)isp1362_hcd->data_reg, dp, len >> 1);
+                dp += len & ~1;
+                len &= 1;
+        }
+
+        BUG_ON(len & ~1);
+        if (len > 0) {
+                /* finally write any trailing byte; we don't need to care
+                 * about the high byte of the last word written
+                 */
+                data = (u16)*dp;
+                RDBG("%s: Sending trailing byte %02x from mem @ %08x\n", __func__,
+                        data, (u32)dp);
+                isp1362_write_data16(isp1362_hcd, data);
+        }
+}
+
+#define isp1362_read_reg16(d, r)                ({                      \
+        u16 __v;                                                        \
+        REG_WIDTH_TEST(ISP1362_REG_##r, REG_WIDTH_16);                  \
+        isp1362_write_addr(d, ISP1362_REG_##r);                         \
+        __v = isp1362_read_data16(d);                                   \
+        RDBG("%s: Read %04x from %s[%02x]\n", __func__, __v, #r,        \
+             ISP1362_REG_NO(ISP1362_REG_##r));                          \
+        __v;                                                            \
+})
+
+#define isp1362_read_reg32(d, r)                ({                      \
+        u32 __v;                                                        \
+        REG_WIDTH_TEST(ISP1362_REG_##r, REG_WIDTH_32);                  \
+        isp1362_write_addr(d, ISP1362_REG_##r);                         \
+        __v = isp1362_read_data32(d);                                   \
+        RDBG("%s: Read %08x from %s[%02x]\n", __func__, __v, #r,        \
+             ISP1362_REG_NO(ISP1362_REG_##r));                          \
+        __v;                                                            \
+})
+
+#define isp1362_write_reg16(d, r, v)    {                                       \
+        REG_WIDTH_TEST(ISP1362_REG_##r, REG_WIDTH_16);                          \
+        isp1362_write_addr(d, (ISP1362_REG_##r) | ISP1362_REG_WRITE_OFFSET);    \
+        isp1362_write_data16(d, (u16)(v));                                      \
+        RDBG("%s: Wrote %04x to %s[%02x]\n", __func__, (u16)(v), #r,    \
+             ISP1362_REG_NO(ISP1362_REG_##r));                                  \
+}
+
+#define isp1362_write_reg32(d, r, v)    {                                       \
+        REG_WIDTH_TEST(ISP1362_REG_##r, REG_WIDTH_32);                          \
+        isp1362_write_addr(d, (ISP1362_REG_##r) | ISP1362_REG_WRITE_OFFSET);    \
+        isp1362_write_data32(d, (u32)(v));                                      \
+        RDBG("%s: Wrote %08x to %s[%02x]\n", __func__, (u32)(v), #r,    \
+             ISP1362_REG_NO(ISP1362_REG_##r));                                  \
+}
+
+#define isp1362_set_mask16(d, r, m) {                   \
+        u16 __v;                                        \
+        __v = isp1362_read_reg16(d, r);                 \
+        if ((__v | m) != __v)                           \
+                isp1362_write_reg16(d, r, __v | m);     \
+}
+
+#define isp1362_clr_mask16(d, r, m) {                   \
+        u16 __v;                                        \
+        __v = isp1362_read_reg16(d, r);                 \
+        if ((__v & ~m) != __v)                  \
+                isp1362_write_reg16(d, r, __v & ~m);    \
+}
+
+#define isp1362_set_mask32(d, r, m) {                   \
+        u32 __v;                                        \
+        __v = isp1362_read_reg32(d, r);                 \
+        if ((__v | m) != __v)                           \
+                isp1362_write_reg32(d, r, __v | m);     \
+}
+
+#define isp1362_clr_mask32(d, r, m) {                   \
+        u32 __v;                                        \
+        __v = isp1362_read_reg32(d, r);                 \
+        if ((__v & ~m) != __v)                  \
+                isp1362_write_reg32(d, r, __v & ~m);    \
+}
+
+#ifdef ISP1362_DEBUG
+#define isp1362_show_reg(d, r) {                                                                \
+        if ((ISP1362_REG_##r & REG_WIDTH_MASK) == REG_WIDTH_32)                 \
+                DBG(0, "%-12s[%02x]: %08x\n", #r,                                       \
+                        ISP1362_REG_NO(ISP1362_REG_##r), isp1362_read_reg32(d, r));     \
+        else                                                                    \
+                DBG(0, "%-12s[%02x]:     %04x\n", #r,                                   \
+                        ISP1362_REG_NO(ISP1362_REG_##r), isp1362_read_reg16(d, r));     \
+}
+#else
+#define isp1362_show_reg(d, r)  do {} while (0)
+#endif
+
+static void __attribute__((__unused__)) isp1362_show_regs(struct isp1362_hcd *isp1362_hcd)
+{
+        isp1362_show_reg(isp1362_hcd, HCREVISION);
+        isp1362_show_reg(isp1362_hcd, HCCONTROL);
+        isp1362_show_reg(isp1362_hcd, HCCMDSTAT);
+        isp1362_show_reg(isp1362_hcd, HCINTSTAT);
+        isp1362_show_reg(isp1362_hcd, HCINTENB);
+        isp1362_show_reg(isp1362_hcd, HCFMINTVL);
+        isp1362_show_reg(isp1362_hcd, HCFMREM);
+        isp1362_show_reg(isp1362_hcd, HCFMNUM);
+        isp1362_show_reg(isp1362_hcd, HCLSTHRESH);
+        isp1362_show_reg(isp1362_hcd, HCRHDESCA);
+        isp1362_show_reg(isp1362_hcd, HCRHDESCB);
+        isp1362_show_reg(isp1362_hcd, HCRHSTATUS);
+        isp1362_show_reg(isp1362_hcd, HCRHPORT1);
+        isp1362_show_reg(isp1362_hcd, HCRHPORT2);
+
+        isp1362_show_reg(isp1362_hcd, HCHWCFG);
+        isp1362_show_reg(isp1362_hcd, HCDMACFG);
+        isp1362_show_reg(isp1362_hcd, HCXFERCTR);
+        isp1362_show_reg(isp1362_hcd, HCuPINT);
+
+        if (in_interrupt())
+                DBG(0, "%-12s[%02x]:     %04x\n", "HCuPINTENB",
+                         ISP1362_REG_NO(ISP1362_REG_HCuPINTENB), isp1362_hcd->irqenb);
+        else
+                isp1362_show_reg(isp1362_hcd, HCuPINTENB);
+        isp1362_show_reg(isp1362_hcd, HCCHIPID);
+        isp1362_show_reg(isp1362_hcd, HCSCRATCH);
+        isp1362_show_reg(isp1362_hcd, HCBUFSTAT);
+        isp1362_show_reg(isp1362_hcd, HCDIRADDR);
+        /* Access would advance fifo
+         * isp1362_show_reg(isp1362_hcd, HCDIRDATA);
+         */
+        isp1362_show_reg(isp1362_hcd, HCISTLBUFSZ);
+        isp1362_show_reg(isp1362_hcd, HCISTLRATE);
+        isp1362_show_reg(isp1362_hcd, HCINTLBUFSZ);
+        isp1362_show_reg(isp1362_hcd, HCINTLBLKSZ);
+        isp1362_show_reg(isp1362_hcd, HCINTLDONE);
+        isp1362_show_reg(isp1362_hcd, HCINTLSKIP);
+        isp1362_show_reg(isp1362_hcd, HCINTLLAST);
+        isp1362_show_reg(isp1362_hcd, HCINTLCURR);
+        isp1362_show_reg(isp1362_hcd, HCATLBUFSZ);
+        isp1362_show_reg(isp1362_hcd, HCATLBLKSZ);
+        /* only valid after ATL_DONE interrupt
+         * isp1362_show_reg(isp1362_hcd, HCATLDONE);
+         */
+        isp1362_show_reg(isp1362_hcd, HCATLSKIP);
+        isp1362_show_reg(isp1362_hcd, HCATLLAST);
+        isp1362_show_reg(isp1362_hcd, HCATLCURR);
+        isp1362_show_reg(isp1362_hcd, HCATLDTC);
+        isp1362_show_reg(isp1362_hcd, HCATLDTCTO);
+}
+
+static void isp1362_write_diraddr(struct isp1362_hcd *isp1362_hcd, u16 offset, u16 len)
+{
+        _BUG_ON(offset & 1);
+        _BUG_ON(offset >= ISP1362_BUF_SIZE);
+        _BUG_ON(len > ISP1362_BUF_SIZE);
+        _BUG_ON(offset + len > ISP1362_BUF_SIZE);
+        len = (len + 1) & ~1;
+
+        isp1362_clr_mask16(isp1362_hcd, HCDMACFG, HCDMACFG_CTR_ENABLE);
+        isp1362_write_reg32(isp1362_hcd, HCDIRADDR,
+                            HCDIRADDR_ADDR(offset) | HCDIRADDR_COUNT(len));
+}
+
+static void isp1362_read_buffer(struct isp1362_hcd *isp1362_hcd, void *buf, u16 offset, int len)
+{
+        _BUG_ON(offset & 1);
+
+        isp1362_write_diraddr(isp1362_hcd, offset, len);
+
+        DBG(3, "%s: Reading %d byte from buffer @%04x to memory @ %08x\n", __func__,
+            len, offset, (u32)buf);
+
+        isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_EOT);
+        _WARN_ON((isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT));
+
+        isp1362_write_addr(isp1362_hcd, ISP1362_REG_HCDIRDATA);
+
+        isp1362_read_fifo(isp1362_hcd, buf, len);
+        _WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT));
+        isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_EOT);
+        _WARN_ON((isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT));
+}
+
+static void isp1362_write_buffer(struct isp1362_hcd *isp1362_hcd, void *buf, u16 offset, int len)
+{
+        _BUG_ON(offset & 1);
+
+        isp1362_write_diraddr(isp1362_hcd, offset, len);
+
+        DBG(3, "%s: Writing %d byte to buffer @%04x from memory @ %08x\n", __func__,
+            len, offset, (u32)buf);
+
+        isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_EOT);
+        _WARN_ON((isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT));
+
+        isp1362_write_addr(isp1362_hcd, ISP1362_REG_HCDIRDATA | ISP1362_REG_WRITE_OFFSET);
+        isp1362_write_fifo(isp1362_hcd, buf, len);
+
+        _WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT));
+        isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_EOT);
+        _WARN_ON((isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT));
+}
+
+static void __attribute__((unused)) dump_data(char *buf, int len)
+{
+        if (dbg_level > 0) {
+                int k;
+                int lf = 0;
+
+                for (k = 0; k < len; ++k) {
+                        if (!lf)
+                                DBG(0, "%04x:", k);
+                        printk(" %02x", ((u8 *) buf)[k]);
+                        lf = 1;
+                        if (!k)
+                                continue;
+                        if (k % 16 == 15) {
+                                printk("\n");
+                                lf = 0;
+                                continue;
+                        }
+                        if (k % 8 == 7)
+                                printk(" ");
+                        if (k % 4 == 3)
+                                printk(" ");
+                }
+                if (lf)
+                        printk("\n");
+        }
+}
+
+#if defined(ISP1362_DEBUG) && defined(PTD_TRACE)
+
+static void dump_ptd(struct ptd *ptd)
+{
+        DBG(0, "EP %p: CC=%x EP=%d DIR=%x CNT=%d LEN=%d MPS=%d TGL=%x ACT=%x FA=%d SPD=%x SF=%x PR=%x LST=%x\n",
+            container_of(ptd, struct isp1362_ep, ptd),
+            PTD_GET_CC(ptd), PTD_GET_EP(ptd), PTD_GET_DIR(ptd),
+            PTD_GET_COUNT(ptd), PTD_GET_LEN(ptd), PTD_GET_MPS(ptd),
+            PTD_GET_TOGGLE(ptd), PTD_GET_ACTIVE(ptd), PTD_GET_FA(ptd),
+            PTD_GET_SPD(ptd), PTD_GET_SF_INT(ptd), PTD_GET_PR(ptd), PTD_GET_LAST(ptd));
+        DBG(0, "  %04x %04x %04x %04x\n", ptd->count, ptd->mps, ptd->len, ptd->faddr);
+}
+
+static void dump_ptd_out_data(struct ptd *ptd, u8 *buf)
+{
+        if (dbg_level > 0) {
+                if (PTD_GET_DIR(ptd) != PTD_DIR_IN && PTD_GET_LEN(ptd)) {
+                        DBG(0, "--out->\n");
+                        dump_data(buf, PTD_GET_LEN(ptd));
+                }
+        }
+}
+
+static void dump_ptd_in_data(struct ptd *ptd, u8 *buf)
+{
+        if (dbg_level > 0) {
+                if (PTD_GET_DIR(ptd) == PTD_DIR_IN && PTD_GET_COUNT(ptd)) {
+                        DBG(0, "<--in--\n");
+                        dump_data(buf, PTD_GET_COUNT(ptd));
+                }
+                DBG(0, "-----\n");
+        }
+}
+
+static void dump_ptd_queue(struct isp1362_ep_queue *epq)
+{
+        struct isp1362_ep *ep;
+        int dbg = dbg_level;
+
+        dbg_level = 1;
+        list_for_each_entry(ep, &epq->active, active) {
+                dump_ptd(&ep->ptd);
+                dump_data(ep->data, ep->length);
+        }
+        dbg_level = dbg;
+}
+#else
+#define dump_ptd(ptd)                   do {} while (0)
+#define dump_ptd_in_data(ptd, buf)      do {} while (0)
+#define dump_ptd_out_data(ptd, buf)     do {} while (0)
+#define dump_ptd_data(ptd, buf)         do {} while (0)
+#define dump_ptd_queue(epq)             do {} while (0)
+#endif
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 15438469f21a..9600a58299db 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -386,6 +386,10 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
                 hwmode |= HW_DACK_POL_HIGH;
         if (priv->devflags & ISP1760_FLAG_DREQ_POL_HIGH)
                 hwmode |= HW_DREQ_POL_HIGH;
+        if (priv->devflags & ISP1760_FLAG_INTR_POL_HIGH)
+                hwmode |= HW_INTR_HIGH_ACT;
+        if (priv->devflags & ISP1760_FLAG_INTR_EDGE_TRIG)
+                hwmode |= HW_INTR_EDGE_TRIG;
 
         /*
          * We have to set this first in case we're in 16-bit mode.
diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h
index 462f4943cb1b..6931ef5c9650 100644
--- a/drivers/usb/host/isp1760-hcd.h
+++ b/drivers/usb/host/isp1760-hcd.h
@@ -142,6 +142,8 @@ typedef void (packet_enqueue)(struct usb_hcd *hcd, struct isp1760_qh *qh,
 #define ISP1760_FLAG_DACK_POL_HIGH      0x00000010 /* DACK active high */
 #define ISP1760_FLAG_DREQ_POL_HIGH      0x00000020 /* DREQ active high */
 #define ISP1760_FLAG_ISP1761            0x00000040 /* Chip is ISP1761 */
+#define ISP1760_FLAG_INTR_POL_HIGH      0x00000080 /* Interrupt polarity active high */
+#define ISP1760_FLAG_INTR_EDGE_TRIG     0x00000100 /* Interrupt edge triggered */
 
 /* chip memory management */
 struct memory_chunk {
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index d4feebfc63bd..1c9f977a5c9c 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -3,6 +3,7 @@
  * Currently there is support for
  * - OpenFirmware
  * - PCI
+ * - PDEV (generic platform device centralized driver model)
  *
  * (c) 2007 Sebastian Siewior <bigeasy@linutronix.de>
  *
@@ -11,6 +12,7 @@
 #include <linux/usb.h>
 #include <linux/io.h>
 #include <linux/platform_device.h>
+#include <linux/usb/isp1760.h>
 
 #include "../core/hcd.h"
 #include "isp1760-hcd.h"
@@ -308,6 +310,8 @@ static int __devinit isp1760_plat_probe(struct platform_device *pdev)
         struct resource *mem_res;
         struct resource *irq_res;
         resource_size_t mem_size;
+        struct isp1760_platform_data *priv = pdev->dev.platform_data;
+        unsigned int devflags = 0;
         unsigned long irqflags = IRQF_SHARED | IRQF_DISABLED;
 
         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -330,8 +334,23 @@ static int __devinit isp1760_plat_probe(struct platform_device *pdev)
         }
         irqflags |= irq_res->flags & IRQF_TRIGGER_MASK;
 
+        if (priv) {
+                if (priv->is_isp1761)
+                        devflags |= ISP1760_FLAG_ISP1761;
+                if (priv->bus_width_16)
+                        devflags |= ISP1760_FLAG_BUS_WIDTH_16;
+                if (priv->port1_otg)
+                        devflags |= ISP1760_FLAG_OTG_EN;
+                if (priv->analog_oc)
+                        devflags |= ISP1760_FLAG_ANALOG_OC;
+                if (priv->dack_polarity_high)
+                        devflags |= ISP1760_FLAG_DACK_POL_HIGH;
+                if (priv->dreq_polarity_high)
+                        devflags |= ISP1760_FLAG_DREQ_POL_HIGH;
+        }
+
         hcd = isp1760_register(mem_res->start, mem_size, irq_res->start,
-                               irqflags, &pdev->dev, dev_name(&pdev->dev), 0);
+                               irqflags, &pdev->dev, dev_name(&pdev->dev), devflags);
         if (IS_ERR(hcd)) {
                 pr_warning("isp1760: Failed to register the HCD device\n");
                 ret = -ENODEV;
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index bb5e6f671578..7ccffcbe7b6f 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -148,7 +148,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
         at91_start_hc(pdev);
         ohci_hcd_init(hcd_to_ohci(hcd));
 
-        retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_DISABLED);
+        retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
         if (retval == 0)
                 return retval;
 
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 2ac4e022a13f..e4380082ebb1 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -248,10 +248,9 @@ static int ohci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int ohci_hcd_au1xxx_drv_suspend(struct platform_device *pdev,
-                                        pm_message_t message)
+static int ohci_hcd_au1xxx_drv_suspend(struct device *dev)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
         unsigned long flags;
         int rc;
@@ -274,10 +273,6 @@ static int ohci_hcd_au1xxx_drv_suspend(struct platform_device *pdev,
         ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
         (void)ohci_readl(ohci, &ohci->regs->intrdisable);
 
-        /* make sure snapshot being resumed re-enumerates everything */
-        if (message.event == PM_EVENT_PRETHAW)
-                ohci_usb_reset(ohci);
-
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
         au1xxx_stop_ohc();
@@ -287,9 +282,9 @@ bail:
         return rc;
 }
 
-static int ohci_hcd_au1xxx_drv_resume(struct platform_device *pdev)
+static int ohci_hcd_au1xxx_drv_resume(struct device *dev)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
 
         au1xxx_start_ohc();
 
@@ -298,20 +293,26 @@ static int ohci_hcd_au1xxx_drv_resume(struct platform_device *pdev)
 
         return 0;
 }
+
+static struct dev_pm_ops au1xxx_ohci_pmops = {
+        .suspend        = ohci_hcd_au1xxx_drv_suspend,
+        .resume         = ohci_hcd_au1xxx_drv_resume,
+};
+
+#define AU1XXX_OHCI_PMOPS &au1xxx_ohci_pmops
+
 #else
-#define ohci_hcd_au1xxx_drv_suspend NULL
-#define ohci_hcd_au1xxx_drv_resume NULL
+#define AU1XXX_OHCI_PMOPS NULL
 #endif
 
 static struct platform_driver ohci_hcd_au1xxx_driver = {
         .probe          = ohci_hcd_au1xxx_drv_probe,
         .remove         = ohci_hcd_au1xxx_drv_remove,
         .shutdown       = usb_hcd_platform_shutdown,
-        .suspend        = ohci_hcd_au1xxx_drv_suspend,
-        .resume         = ohci_hcd_au1xxx_drv_resume,
         .driver         = {
                 .name   = "au1xxx-ohci",
                 .owner  = THIS_MODULE,
+                .pm     = AU1XXX_OHCI_PMOPS,
         },
 };
 
diff --git a/drivers/usb/host/ohci-ep93xx.c b/drivers/usb/host/ohci-ep93xx.c
index b0dbf4157d29..4e681613e7ae 100644
--- a/drivers/usb/host/ohci-ep93xx.c
+++ b/drivers/usb/host/ohci-ep93xx.c
@@ -188,7 +188,6 @@ static int ohci_hcd_ep93xx_drv_resume(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        int status;
 
         if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 58151687d351..78bb7710f36d 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -34,7 +34,6 @@
 #include <linux/usb/otg.h>
 #include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
-#include <linux/reboot.h>
 #include <linux/workqueue.h>
 #include <linux/debugfs.h>
 
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index e44dc2cbca24..b5294a9344de 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -177,9 +177,13 @@ static inline void pxa27x_setup_hc(struct pxa27x_ohci *ohci,
 
         if (inf->flags & NO_OC_PROTECTION)
                 uhcrhda |= UHCRHDA_NOCP;
+        else
+                uhcrhda &= ~UHCRHDA_NOCP;
 
         if (inf->flags & OC_MODE_PERPORT)
                 uhcrhda |= UHCRHDA_OCPM;
+        else
+                uhcrhda &= ~UHCRHDA_OCPM;
 
         if (inf->power_on_delay) {
                 uhcrhda &= ~UHCRHDA_POTPGT(0xff);
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 5ac489ee3dab..50f57f468836 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -33,7 +33,6 @@
 #include <linux/timer.h>
 #include <linux/list.h>
 #include <linux/interrupt.h>
-#include <linux/reboot.h>
 #include <linux/usb.h>
 #include <linux/moduleparam.h>
 #include <linux/dma-mapping.h>
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index 83b5f9cea85a..23cf3bde4762 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -475,4 +475,4 @@ static void __devinit quirk_usb_early_handoff(struct pci_dev *pdev)
         else if (pdev->class == PCI_CLASS_SERIAL_USB_XHCI)
                 quirk_usb_handoff_xhci(pdev);
 }
-DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, quirk_usb_early_handoff);
+DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, quirk_usb_early_handoff);
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index a949259f18b9..5b22a4d1c9e4 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -719,8 +719,12 @@ retry:
                 /* port status seems weird until after reset, so
                  * force the reset and make khubd clean up later.
                  */
-                sl811->port1 |= (1 << USB_PORT_FEAT_C_CONNECTION)
-                                | (1 << USB_PORT_FEAT_CONNECTION);
+                if (sl811->stat_insrmv & 1)
+                        sl811->port1 |= 1 << USB_PORT_FEAT_CONNECTION;
+                else
+                        sl811->port1 &= ~(1 << USB_PORT_FEAT_CONNECTION);
+
+                sl811->port1 |= 1 << USB_PORT_FEAT_C_CONNECTION;
 
         } else if (irqstat & SL11H_INTMASK_RD) {
                 if (sl811->port1 & (1 << USB_PORT_FEAT_SUSPEND)) {
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 64e57bfe236b..acd582c02802 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -1422,7 +1422,6 @@ static int uhci_urb_enqueue(struct usb_hcd *hcd,
                 goto err_submit_failed;
 
         /* Add this URB to the QH */
-        urbp->qh = qh;
         list_add_tail(&urbp->node, &qh->queue);
 
         /* If the new URB is the first and only one on this QH then either
diff --git a/drivers/usb/host/whci/asl.c b/drivers/usb/host/whci/asl.c
index c2050785a819..c632437c7649 100644
--- a/drivers/usb/host/whci/asl.c
+++ b/drivers/usb/host/whci/asl.c
@@ -227,11 +227,21 @@ void scan_async_work(struct work_struct *work)
         /*
          * Now that the ASL is updated, complete the removal of any
          * removed qsets.
+         *
+         * If the qset was to be reset, do so and reinsert it into the
+         * ASL if it has pending transfers.
          */
         spin_lock_irq(&whc->lock);
 
         list_for_each_entry_safe(qset, t, &whc->async_removed_list, list_node) {
                 qset_remove_complete(whc, qset);
+                if (qset->reset) {
+                        qset_reset(whc, qset);
+                        if (!list_empty(&qset->stds)) {
+                                asl_qset_insert_begin(whc, qset);
+                                queue_work(whc->workqueue, &whc->async_work);
+                        }
+                }
         }
 
         spin_unlock_irq(&whc->lock);
@@ -267,7 +277,7 @@ int asl_urb_enqueue(struct whc *whc, struct urb *urb, gfp_t mem_flags)
         else
                 err = qset_add_urb(whc, qset, urb, GFP_ATOMIC);
         if (!err) {
-                if (!qset->in_sw_list)
+                if (!qset->in_sw_list && !qset->remove)
                         asl_qset_insert_begin(whc, qset);
         } else
                 usb_hcd_unlink_urb_from_ep(&whc->wusbhc.usb_hcd, urb);
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index e019a5058ab8..687b622a1612 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -192,19 +192,23 @@ static void whc_endpoint_reset(struct usb_hcd *usb_hcd,
         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
         struct whc *whc = wusbhc_to_whc(wusbhc);
         struct whc_qset *qset;
+        unsigned long flags;
+
+        spin_lock_irqsave(&whc->lock, flags);
 
         qset = ep->hcpriv;
         if (qset) {
                 qset->remove = 1;
+                qset->reset = 1;
 
                 if (usb_endpoint_xfer_bulk(&ep->desc)
                     || usb_endpoint_xfer_control(&ep->desc))
                         queue_work(whc->workqueue, &whc->async_work);
                 else
                         queue_work(whc->workqueue, &whc->periodic_work);
-
-                qset_reset(whc, qset);
         }
+
+        spin_unlock_irqrestore(&whc->lock, flags);
 }
 
 
diff --git a/drivers/usb/host/whci/pzl.c b/drivers/usb/host/whci/pzl.c
index ff4ef9e910d9..a9e05bac6646 100644
--- a/drivers/usb/host/whci/pzl.c
+++ b/drivers/usb/host/whci/pzl.c
@@ -255,11 +255,21 @@ void scan_periodic_work(struct work_struct *work)
         /*
          * Now that the PZL is updated, complete the removal of any
          * removed qsets.
+         *
+         * If the qset was to be reset, do so and reinsert it into the
+         * PZL if it has pending transfers.
          */
         spin_lock_irq(&whc->lock);
 
         list_for_each_entry_safe(qset, t, &whc->periodic_removed_list, list_node) {
                 qset_remove_complete(whc, qset);
+                if (qset->reset) {
+                        qset_reset(whc, qset);
+                        if (!list_empty(&qset->stds)) {
+                                qset_insert_in_sw_list(whc, qset);
+                                queue_work(whc->workqueue, &whc->periodic_work);
+                        }
+                }
         }
 
         spin_unlock_irq(&whc->lock);
@@ -295,7 +305,7 @@ int pzl_urb_enqueue(struct whc *whc, struct urb *urb, gfp_t mem_flags)
         else
                 err = qset_add_urb(whc, qset, urb, GFP_ATOMIC);
         if (!err) {
-                if (!qset->in_sw_list)
+                if (!qset->in_sw_list && !qset->remove)
                         qset_insert_in_sw_list(whc, qset);
         } else
                 usb_hcd_unlink_urb_from_ep(&whc->wusbhc.usb_hcd, urb);
diff --git a/drivers/usb/host/whci/qset.c b/drivers/usb/host/whci/qset.c
index 640b38fbd051..1b9dc1571570 100644
--- a/drivers/usb/host/whci/qset.c
+++ b/drivers/usb/host/whci/qset.c
@@ -103,7 +103,6 @@ static void qset_fill_qh(struct whc_qset *qset, struct urb *urb)
 void qset_clear(struct whc *whc, struct whc_qset *qset)
 {
         qset->td_start = qset->td_end = qset->ntds = 0;
-        qset->remove = 0;
 
         qset->qh.link = cpu_to_le32(QH_LINK_NTDS(8) | QH_LINK_T);
         qset->qh.status = qset->qh.status & QH_STATUS_SEQ_MASK;
@@ -125,7 +124,7 @@ void qset_clear(struct whc *whc, struct whc_qset *qset)
  */
 void qset_reset(struct whc *whc, struct whc_qset *qset)
 {
-        wait_for_completion(&qset->remove_complete);
+        qset->reset = 0;
 
         qset->qh.status &= ~QH_STATUS_SEQ_MASK;
         qset->qh.cur_window = cpu_to_le32((1 << qset->max_burst) - 1);
@@ -156,6 +155,7 @@ struct whc_qset *get_qset(struct whc *whc, struct urb *urb,
 
 void qset_remove_complete(struct whc *whc, struct whc_qset *qset)
 {
+        qset->remove = 0;
         list_del_init(&qset->list_node);
         complete(&qset->remove_complete);
 }
diff --git a/drivers/usb/host/whci/whci-hc.h b/drivers/usb/host/whci/whci-hc.h
index 794dba0d0f0a..e8d0001605be 100644
--- a/drivers/usb/host/whci/whci-hc.h
+++ b/drivers/usb/host/whci/whci-hc.h
@@ -264,6 +264,7 @@ struct whc_qset {
         unsigned in_sw_list:1;
         unsigned in_hw_list:1;
         unsigned remove:1;
+        unsigned reset:1;
         struct urb *pause_after_urb;
         struct completion remove_complete;
         int max_burst;
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index 705e34324156..33128d52f212 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -413,7 +413,8 @@ void xhci_dbg_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx)
         int i;
 
         struct xhci_slot_ctx *slot_ctx = xhci_get_slot_ctx(xhci, ctx);
-        dma_addr_t dma = ctx->dma + ((unsigned long)slot_ctx - (unsigned long)ctx);
+        dma_addr_t dma = ctx->dma +
+                ((unsigned long)slot_ctx - (unsigned long)ctx->bytes);
         int csz = HCC_64BYTE_CONTEXT(xhci->hcc_params);
 
         xhci_dbg(xhci, "Slot Context:\n");
@@ -459,7 +460,7 @@ void xhci_dbg_ep_ctx(struct xhci_hcd *xhci,
         for (i = 0; i < last_ep_ctx; ++i) {
                 struct xhci_ep_ctx *ep_ctx = xhci_get_ep_ctx(xhci, ctx, i);
                 dma_addr_t dma = ctx->dma +
-                        ((unsigned long)ep_ctx - (unsigned long)ctx);
+                        ((unsigned long)ep_ctx - (unsigned long)ctx->bytes);
 
                 xhci_dbg(xhci, "Endpoint %02d Context:\n", i);
                 xhci_dbg(xhci, "@%p (virt) @%08llx (dma) %#08x - ep_info\n",
diff --git a/drivers/usb/host/xhci-hcd.c b/drivers/usb/host/xhci-hcd.c
index 816c39caca1c..99911e727e0b 100644
--- a/drivers/usb/host/xhci-hcd.c
+++ b/drivers/usb/host/xhci-hcd.c
@@ -22,12 +22,18 @@
 
 #include <linux/irq.h>
 #include <linux/module.h>
+#include <linux/moduleparam.h>
 
 #include "xhci.h"
 
 #define DRIVER_AUTHOR "Sarah Sharp"
 #define DRIVER_DESC "'eXtensible' Host Controller (xHC) Driver"
 
+/* Some 0.95 hardware can't handle the chain bit on a Link TRB being cleared */
+static int link_quirk;
+module_param(link_quirk, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(link_quirk, "Don't clear the chain bit on a link TRB");
+
 /* TODO: copied from ehci-hcd.c - can this be refactored? */
 /*
  * handshake - spin reading hc until handshake completes or fails
@@ -214,6 +220,12 @@ int xhci_init(struct usb_hcd *hcd)
 
         xhci_dbg(xhci, "xhci_init\n");
         spin_lock_init(&xhci->lock);
+        if (link_quirk) {
+                xhci_dbg(xhci, "QUIRK: Not clearing Link TRB chain bits.\n");
+                xhci->quirks |= XHCI_LINK_TRB_QUIRK;
+        } else {
+                xhci_dbg(xhci, "xHCI doesn't need link TRB QUIRK\n");
+        }
         retval = xhci_mem_init(xhci, GFP_KERNEL);
         xhci_dbg(xhci, "Finished xhci_init\n");
 
@@ -339,13 +351,14 @@ void xhci_event_ring_work(unsigned long arg)
         xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring);
         xhci_dbg_cmd_ptrs(xhci);
         for (i = 0; i < MAX_HC_SLOTS; ++i) {
-                if (xhci->devs[i]) {
-                        for (j = 0; j < 31; ++j) {
-                                if (xhci->devs[i]->ep_rings[j]) {
-                                        xhci_dbg(xhci, "Dev %d endpoint ring %d:\n", i, j);
-                                        xhci_debug_segment(xhci, xhci->devs[i]->ep_rings[j]->deq_seg);
-                                }
-                        }
+                if (!xhci->devs[i])
+                        continue;
+                for (j = 0; j < 31; ++j) {
+                        struct xhci_ring *ring = xhci->devs[i]->eps[j].ring;
+                        if (!ring)
+                                continue;
+                        xhci_dbg(xhci, "Dev %d endpoint ring %d:\n", i, j);
+                        xhci_debug_segment(xhci, ring->deq_seg);
                 }
         }
 
@@ -555,13 +568,22 @@ unsigned int xhci_get_endpoint_flag(struct usb_endpoint_descriptor *desc)
         return 1 << (xhci_get_endpoint_index(desc) + 1);
 }
 
+/* Find the flag for this endpoint (for use in the control context).  Use the
+ * endpoint index to create a bitmask.  The slot context is bit 0, endpoint 0 is
+ * bit 1, etc.
+ */
+unsigned int xhci_get_endpoint_flag_from_index(unsigned int ep_index)
+{
+        return 1 << (ep_index + 1);
+}
+
 /* Compute the last valid endpoint context index.  Basically, this is the
  * endpoint index plus one.  For slot contexts with more than valid endpoint,
  * we find the most significant bit set in the added contexts flags.
  * e.g. ep 1 IN (with epnum 0x81) => added_ctxs = 0b1000
  * fls(0b1000) = 4, but the endpoint context index is 3, so subtract one.
  */
-static inline unsigned int xhci_last_valid_endpoint(u32 added_ctxs)
+unsigned int xhci_last_valid_endpoint(u32 added_ctxs)
 {
         return fls(added_ctxs) - 1;
 }
@@ -589,6 +611,71 @@ int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
         return 1;
 }
 
+static int xhci_configure_endpoint(struct xhci_hcd *xhci,
+                struct usb_device *udev, struct xhci_command *command,
+                bool ctx_change, bool must_succeed);
+
+/*
+ * Full speed devices may have a max packet size greater than 8 bytes, but the
+ * USB core doesn't know that until it reads the first 8 bytes of the
+ * descriptor.  If the usb_device's max packet size changes after that point,
+ * we need to issue an evaluate context command and wait on it.
+ */
+static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
+                unsigned int ep_index, struct urb *urb)
+{
+        struct xhci_container_ctx *in_ctx;
+        struct xhci_container_ctx *out_ctx;
+        struct xhci_input_control_ctx *ctrl_ctx;
+        struct xhci_ep_ctx *ep_ctx;
+        int max_packet_size;
+        int hw_max_packet_size;
+        int ret = 0;
+
+        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;
+        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",
+                                max_packet_size);
+                xhci_dbg(xhci, "Max packet size in xHCI HW = %d\n",
+                                hw_max_packet_size);
+                xhci_dbg(xhci, "Issuing evaluate context command.\n");
+
+                /* Set up the modified control endpoint 0 */
+                xhci_endpoint_copy(xhci, xhci->devs[slot_id]->in_ctx,
+                                xhci->devs[slot_id]->out_ctx, ep_index);
+                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);
+
+                /* 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->drop_flags = 0;
+
+                xhci_dbg(xhci, "Slot %d input context\n", slot_id);
+                xhci_dbg_ctx(xhci, in_ctx, ep_index);
+                xhci_dbg(xhci, "Slot %d output context\n", slot_id);
+                xhci_dbg_ctx(xhci, out_ctx, ep_index);
+
+                ret = xhci_configure_endpoint(xhci, urb->dev, NULL,
+                                true, false);
+
+                /* Clean up the input context for later use by bandwidth
+                 * functions.
+                 */
+                ctrl_ctx->add_flags = SLOT_FLAG;
+        }
+        return ret;
+}
+
 /*
  * non-error returns are a promise to giveback() the urb later
  * we drop ownership so next owner (or urb unlink) can get it
@@ -600,13 +687,13 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
         int ret = 0;
         unsigned int slot_id, ep_index;
 
+
         if (!urb || xhci_check_args(hcd, urb->dev, urb->ep, true, __func__) <= 0)
                 return -EINVAL;
 
         slot_id = urb->dev->slot_id;
         ep_index = xhci_get_endpoint_index(&urb->ep->desc);
 
-        spin_lock_irqsave(&xhci->lock, flags);
         if (!xhci->devs || !xhci->devs[slot_id]) {
                 if (!in_interrupt())
                         dev_warn(&urb->dev->dev, "WARN: urb submitted for dev with no Slot ID\n");
@@ -619,19 +706,38 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                 ret = -ESHUTDOWN;
                 goto exit;
         }
-        if (usb_endpoint_xfer_control(&urb->ep->desc))
+        if (usb_endpoint_xfer_control(&urb->ep->desc)) {
+                /* Check to see if the max packet size for the default control
+                 * endpoint changed during FS device enumeration
+                 */
+                if (urb->dev->speed == USB_SPEED_FULL) {
+                        ret = xhci_check_maxpacket(xhci, slot_id,
+                                        ep_index, urb);
+                        if (ret < 0)
+                                return ret;
+                }
+
                 /* We have a spinlock and interrupts disabled, so we must pass
                  * atomic context to this function, which may allocate memory.
                  */
+                spin_lock_irqsave(&xhci->lock, flags);
                 ret = xhci_queue_ctrl_tx(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
-        else if (usb_endpoint_xfer_bulk(&urb->ep->desc))
+                spin_unlock_irqrestore(&xhci->lock, flags);
+        } else if (usb_endpoint_xfer_bulk(&urb->ep->desc)) {
+                spin_lock_irqsave(&xhci->lock, flags);
                 ret = xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
-        else
+                spin_unlock_irqrestore(&xhci->lock, flags);
+        } else if (usb_endpoint_xfer_int(&urb->ep->desc)) {
+                spin_lock_irqsave(&xhci->lock, flags);
+                ret = xhci_queue_intr_tx(xhci, GFP_ATOMIC, urb,
+                                slot_id, ep_index);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+        } else {
                 ret = -EINVAL;
+        }
 exit:
-        spin_unlock_irqrestore(&xhci->lock, flags);
         return ret;
 }
 
@@ -674,6 +780,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         struct xhci_td *td;
         unsigned int ep_index;
         struct xhci_ring *ep_ring;
+        struct xhci_virt_ep *ep;
 
         xhci = hcd_to_xhci(hcd);
         spin_lock_irqsave(&xhci->lock, flags);
@@ -686,17 +793,18 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         xhci_dbg(xhci, "Event ring:\n");
         xhci_debug_ring(xhci, xhci->event_ring);
         ep_index = xhci_get_endpoint_index(&urb->ep->desc);
-        ep_ring = xhci->devs[urb->dev->slot_id]->ep_rings[ep_index];
+        ep = &xhci->devs[urb->dev->slot_id]->eps[ep_index];
+        ep_ring = ep->ring;
         xhci_dbg(xhci, "Endpoint ring:\n");
         xhci_debug_ring(xhci, ep_ring);
         td = (struct xhci_td *) urb->hcpriv;
 
-        ep_ring->cancels_pending++;
-        list_add_tail(&td->cancelled_td_list, &ep_ring->cancelled_td_list);
+        ep->cancels_pending++;
+        list_add_tail(&td->cancelled_td_list, &ep->cancelled_td_list);
         /* Queue a stop endpoint command, but only if this is
          * the first cancellation to be handled.
          */
-        if (ep_ring->cancels_pending == 1) {
+        if (ep->cancels_pending == 1) {
                 xhci_queue_stop_endpoint(xhci, urb->dev->slot_id, ep_index);
                 xhci_ring_cmd_db(xhci);
         }
@@ -930,6 +1038,141 @@ 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)
+{
+        int ret;
+
+        switch (*cmd_status) {
+        case COMP_ENOMEM:
+                dev_warn(&udev->dev, "Not enough host controller resources "
+                                "for new device state.\n");
+                ret = -ENOMEM;
+                /* FIXME: can we allocate more resources for the HC? */
+                break;
+        case COMP_BW_ERR:
+                dev_warn(&udev->dev, "Not enough bandwidth "
+                                "for new device state.\n");
+                ret = -ENOSPC;
+                /* FIXME: can we go back to the old state? */
+                break;
+        case COMP_TRB_ERR:
+                /* the HCD set up something wrong */
+                dev_warn(&udev->dev, "ERROR: Endpoint drop flag = 0, "
+                                "add flag = 1, "
+                                "and endpoint is not disabled.\n");
+                ret = -EINVAL;
+                break;
+        case COMP_SUCCESS:
+                dev_dbg(&udev->dev, "Successful Endpoint Configure command\n");
+                ret = 0;
+                break;
+        default:
+                xhci_err(xhci, "ERROR: unexpected command completion "
+                                "code 0x%x.\n", *cmd_status);
+                ret = -EINVAL;
+                break;
+        }
+        return ret;
+}
+
+static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
+                struct usb_device *udev, int *cmd_status)
+{
+        int ret;
+        struct xhci_virt_device *virt_dev = xhci->devs[udev->slot_id];
+
+        switch (*cmd_status) {
+        case COMP_EINVAL:
+                dev_warn(&udev->dev, "WARN: xHCI driver setup invalid evaluate "
+                                "context command.\n");
+                ret = -EINVAL;
+                break;
+        case COMP_EBADSLT:
+                dev_warn(&udev->dev, "WARN: slot not enabled for"
+                                "evaluate context command.\n");
+        case COMP_CTX_STATE:
+                dev_warn(&udev->dev, "WARN: invalid context state for "
+                                "evaluate context command.\n");
+                xhci_dbg_ctx(xhci, virt_dev->out_ctx, 1);
+                ret = -EINVAL;
+                break;
+        case COMP_SUCCESS:
+                dev_dbg(&udev->dev, "Successful evaluate context command\n");
+                ret = 0;
+                break;
+        default:
+                xhci_err(xhci, "ERROR: unexpected command completion "
+                                "code 0x%x.\n", *cmd_status);
+                ret = -EINVAL;
+                break;
+        }
+        return ret;
+}
+
+/* Issue a configure endpoint command or evaluate context command
+ * and wait for it to finish.
+ */
+static int xhci_configure_endpoint(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct xhci_command *command,
+                bool ctx_change, bool must_succeed)
+{
+        int ret;
+        int timeleft;
+        unsigned long flags;
+        struct xhci_container_ctx *in_ctx;
+        struct completion *cmd_completion;
+        int *cmd_status;
+        struct xhci_virt_device *virt_dev;
+
+        spin_lock_irqsave(&xhci->lock, flags);
+        virt_dev = xhci->devs[udev->slot_id];
+        if (command) {
+                in_ctx = command->in_ctx;
+                cmd_completion = command->completion;
+                cmd_status = &command->status;
+                command->command_trb = xhci->cmd_ring->enqueue;
+                list_add_tail(&command->cmd_list, &virt_dev->cmd_list);
+        } else {
+                in_ctx = virt_dev->in_ctx;
+                cmd_completion = &virt_dev->cmd_completion;
+                cmd_status = &virt_dev->cmd_status;
+        }
+
+        if (!ctx_change)
+                ret = xhci_queue_configure_endpoint(xhci, in_ctx->dma,
+                                udev->slot_id, must_succeed);
+        else
+                ret = xhci_queue_evaluate_context(xhci, in_ctx->dma,
+                                udev->slot_id);
+        if (ret < 0) {
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                xhci_dbg(xhci, "FIXME allocate a new ring segment\n");
+                return -ENOMEM;
+        }
+        xhci_ring_cmd_db(xhci);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
+        /* Wait for the configure endpoint command to complete */
+        timeleft = wait_for_completion_interruptible_timeout(
+                        cmd_completion,
+                        USB_CTRL_SET_TIMEOUT);
+        if (timeleft <= 0) {
+                xhci_warn(xhci, "%s while waiting for %s command\n",
+                                timeleft == 0 ? "Timeout" : "Signal",
+                                ctx_change == 0 ?
+                                        "configure endpoint" :
+                                        "evaluate context");
+                /* FIXME cancel the configure endpoint command */
+                return -ETIME;
+        }
+
+        if (!ctx_change)
+                return xhci_configure_endpoint_result(xhci, udev, cmd_status);
+        return xhci_evaluate_context_result(xhci, udev, cmd_status);
+}
+
 /* Called after one or more calls to xhci_add_endpoint() or
  * xhci_drop_endpoint().  If this call fails, the USB core is expected
  * to call xhci_reset_bandwidth().
@@ -944,8 +1187,6 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
 {
         int i;
         int ret = 0;
-        int timeleft;
-        unsigned long flags;
         struct xhci_hcd *xhci;
         struct xhci_virt_device *virt_dev;
         struct xhci_input_control_ctx *ctrl_ctx;
@@ -975,56 +1216,8 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         xhci_dbg_ctx(xhci, virt_dev->in_ctx,
                         LAST_CTX_TO_EP_NUM(slot_ctx->dev_info));
 
-        spin_lock_irqsave(&xhci->lock, flags);
-        ret = xhci_queue_configure_endpoint(xhci, virt_dev->in_ctx->dma,
-                        udev->slot_id);
-        if (ret < 0) {
-                spin_unlock_irqrestore(&xhci->lock, flags);
-                xhci_dbg(xhci, "FIXME allocate a new ring segment\n");
-                return -ENOMEM;
-        }
-        xhci_ring_cmd_db(xhci);
-        spin_unlock_irqrestore(&xhci->lock, flags);
-
-        /* Wait for the configure endpoint command to complete */
-        timeleft = wait_for_completion_interruptible_timeout(
-                        &virt_dev->cmd_completion,
-                        USB_CTRL_SET_TIMEOUT);
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for configure endpoint command\n",
-                                timeleft == 0 ? "Timeout" : "Signal");
-                /* FIXME cancel the configure endpoint command */
-                return -ETIME;
-        }
-
-        switch (virt_dev->cmd_status) {
-        case COMP_ENOMEM:
-                dev_warn(&udev->dev, "Not enough host controller resources "
-                                "for new device state.\n");
-                ret = -ENOMEM;
-                /* FIXME: can we allocate more resources for the HC? */
-                break;
-        case COMP_BW_ERR:
-                dev_warn(&udev->dev, "Not enough bandwidth "
-                                "for new device state.\n");
-                ret = -ENOSPC;
-                /* FIXME: can we go back to the old state? */
-                break;
-        case COMP_TRB_ERR:
-                /* the HCD set up something wrong */
-                dev_warn(&udev->dev, "ERROR: Endpoint drop flag = 0, add flag = 1, "
-                                "and endpoint is not disabled.\n");
-                ret = -EINVAL;
-                break;
-        case COMP_SUCCESS:
-                dev_dbg(&udev->dev, "Successful Endpoint Configure command\n");
-                break;
-        default:
-                xhci_err(xhci, "ERROR: unexpected command completion "
-                                "code 0x%x.\n", virt_dev->cmd_status);
-                ret = -EINVAL;
-                break;
-        }
+        ret = xhci_configure_endpoint(xhci, udev, NULL,
+                        false, false);
         if (ret) {
                 /* Callee should call reset_bandwidth() */
                 return ret;
@@ -1037,10 +1230,10 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         xhci_zero_in_ctx(xhci, virt_dev);
         /* Free any old rings */
         for (i = 1; i < 31; ++i) {
-                if (virt_dev->new_ep_rings[i]) {
-                        xhci_ring_free(xhci, virt_dev->ep_rings[i]);
-                        virt_dev->ep_rings[i] = virt_dev->new_ep_rings[i];
-                        virt_dev->new_ep_rings[i] = NULL;
+                if (virt_dev->eps[i].new_ring) {
+                        xhci_ring_free(xhci, virt_dev->eps[i].ring);
+                        virt_dev->eps[i].ring = virt_dev->eps[i].new_ring;
+                        virt_dev->eps[i].new_ring = NULL;
                 }
         }
 
@@ -1067,14 +1260,93 @@ void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         virt_dev = xhci->devs[udev->slot_id];
         /* Free any rings allocated for added endpoints */
         for (i = 0; i < 31; ++i) {
-                if (virt_dev->new_ep_rings[i]) {
-                        xhci_ring_free(xhci, virt_dev->new_ep_rings[i]);
-                        virt_dev->new_ep_rings[i] = NULL;
+                if (virt_dev->eps[i].new_ring) {
+                        xhci_ring_free(xhci, virt_dev->eps[i].new_ring);
+                        virt_dev->eps[i].new_ring = NULL;
                 }
         }
         xhci_zero_in_ctx(xhci, virt_dev);
 }
 
+static void xhci_setup_input_ctx_for_config_ep(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx,
+                struct xhci_container_ctx *out_ctx,
+                u32 add_flags, u32 drop_flags)
+{
+        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;
+        xhci_slot_copy(xhci, in_ctx, out_ctx);
+        ctrl_ctx->add_flags |= SLOT_FLAG;
+
+        xhci_dbg(xhci, "Input Context:\n");
+        xhci_dbg_ctx(xhci, in_ctx, xhci_last_valid_endpoint(add_flags));
+}
+
+void xhci_setup_input_ctx_for_quirk(struct xhci_hcd *xhci,
+                unsigned int slot_id, unsigned int ep_index,
+                struct xhci_dequeue_state *deq_state)
+{
+        struct xhci_container_ctx *in_ctx;
+        struct xhci_ep_ctx *ep_ctx;
+        u32 added_ctxs;
+        dma_addr_t addr;
+
+        xhci_endpoint_copy(xhci, xhci->devs[slot_id]->in_ctx,
+                        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);
+        addr = xhci_trb_virt_to_dma(deq_state->new_deq_seg,
+                        deq_state->new_deq_ptr);
+        if (addr == 0) {
+                xhci_warn(xhci, "WARN Cannot submit config ep after "
+                                "reset ep command\n");
+                xhci_warn(xhci, "WARN deq seg = %p, deq ptr = %p\n",
+                                deq_state->new_deq_seg,
+                                deq_state->new_deq_ptr);
+                return;
+        }
+        ep_ctx->deq = 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,
+                        xhci->devs[slot_id]->out_ctx, added_ctxs, added_ctxs);
+}
+
+void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
+                struct usb_device *udev, unsigned int ep_index)
+{
+        struct xhci_dequeue_state deq_state;
+        struct xhci_virt_ep *ep;
+
+        xhci_dbg(xhci, "Cleaning up stalled endpoint ring\n");
+        ep = &xhci->devs[udev->slot_id]->eps[ep_index];
+        /* We need to move the HW's dequeue pointer past this TD,
+         * or it will attempt to resend it on the next doorbell ring.
+         */
+        xhci_find_new_dequeue_state(xhci, udev->slot_id,
+                        ep_index, ep->stopped_td,
+                        &deq_state);
+
+        /* HW with the reset endpoint quirk will use the saved dequeue state to
+         * issue a configure endpoint command later.
+         */
+        if (!(xhci->quirks & XHCI_RESET_EP_QUIRK)) {
+                xhci_dbg(xhci, "Queueing new dequeue state\n");
+                xhci_queue_new_dequeue_state(xhci, udev->slot_id,
+                                ep_index, &deq_state);
+        } else {
+                /* Better hope no one uses the input context between now and the
+                 * reset endpoint completion!
+                 */
+                xhci_dbg(xhci, "Setting up input context for "
+                                "configure endpoint command\n");
+                xhci_setup_input_ctx_for_quirk(xhci, udev->slot_id,
+                                ep_index, &deq_state);
+        }
+}
+
 /* Deal with stalled endpoints.  The core should have sent the control message
  * to clear the halt condition.  However, we need to make the xHCI hardware
  * reset its sequence number, since a device will expect a sequence number of
@@ -1089,8 +1361,7 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
         unsigned int ep_index;
         unsigned long flags;
         int ret;
-        struct xhci_dequeue_state deq_state;
-        struct xhci_ring *ep_ring;
+        struct xhci_virt_ep *virt_ep;
 
         xhci = hcd_to_xhci(hcd);
         udev = (struct usb_device *) ep->hcpriv;
@@ -1100,12 +1371,16 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
         if (!ep->hcpriv)
                 return;
         ep_index = xhci_get_endpoint_index(&ep->desc);
-        ep_ring = xhci->devs[udev->slot_id]->ep_rings[ep_index];
-        if (!ep_ring->stopped_td) {
+        virt_ep = &xhci->devs[udev->slot_id]->eps[ep_index];
+        if (!virt_ep->stopped_td) {
                 xhci_dbg(xhci, "Endpoint 0x%x not halted, refusing to reset.\n",
                                 ep->desc.bEndpointAddress);
                 return;
         }
+        if (usb_endpoint_xfer_control(&ep->desc)) {
+                xhci_dbg(xhci, "Control endpoint stall already handled.\n");
+                return;
+        }
 
         xhci_dbg(xhci, "Queueing reset endpoint command\n");
         spin_lock_irqsave(&xhci->lock, flags);
@@ -1116,17 +1391,8 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
          * command.  Better hope that last command worked!
          */
         if (!ret) {
-                xhci_dbg(xhci, "Cleaning up stalled endpoint ring\n");
-                /* We need to move the HW's dequeue pointer past this TD,
-                 * or it will attempt to resend it on the next doorbell ring.
-                 */
-                xhci_find_new_dequeue_state(xhci, udev->slot_id,
-                                ep_index, ep_ring->stopped_td, &deq_state);
-                xhci_dbg(xhci, "Queueing new dequeue state\n");
-                xhci_queue_new_dequeue_state(xhci, ep_ring,
-                                udev->slot_id,
-                                ep_index, &deq_state);
-                kfree(ep_ring->stopped_td);
+                xhci_cleanup_stalled_ring(xhci, udev, ep_index);
+                kfree(virt_ep->stopped_td);
                 xhci_ring_cmd_db(xhci);
         }
         spin_unlock_irqrestore(&xhci->lock, flags);
@@ -1328,6 +1594,88 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         return 0;
 }
 
+/* Once a hub descriptor is fetched for a device, we need to update the xHC's
+ * internal data structures for the device.
+ */
+int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
+                        struct usb_tt *tt, gfp_t mem_flags)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        struct xhci_virt_device *vdev;
+        struct xhci_command *config_cmd;
+        struct xhci_input_control_ctx *ctrl_ctx;
+        struct xhci_slot_ctx *slot_ctx;
+        unsigned long flags;
+        unsigned think_time;
+        int ret;
+
+        /* Ignore root hubs */
+        if (!hdev->parent)
+                return 0;
+
+        vdev = xhci->devs[hdev->slot_id];
+        if (!vdev) {
+                xhci_warn(xhci, "Cannot update hub desc for unknown device.\n");
+                return -EINVAL;
+        }
+        config_cmd = xhci_alloc_command(xhci, true, mem_flags);
+        if (!config_cmd) {
+                xhci_dbg(xhci, "Could not allocate xHCI command structure.\n");
+                return -ENOMEM;
+        }
+
+        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;
+        slot_ctx = xhci_get_slot_ctx(xhci, config_cmd->in_ctx);
+        slot_ctx->dev_info |= DEV_HUB;
+        if (tt->multi)
+                slot_ctx->dev_info |= 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);
+                /* 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.
+                 */
+                think_time = tt->think_time;
+                if (think_time != 0)
+                        think_time = (think_time / 666) - 1;
+                slot_ctx->tt_info |= TT_THINK_TIME(think_time);
+        } else {
+                xhci_dbg(xhci, "xHCI version %x doesn't need hub "
+                                "TT think time or number of ports\n",
+                                (unsigned int) xhci->hci_version);
+        }
+        slot_ctx->dev_state = 0;
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
+        xhci_dbg(xhci, "Set up %s for hub device.\n",
+                        (xhci->hci_version > 0x95) ?
+                        "configure endpoint" : "evaluate context");
+        xhci_dbg(xhci, "Slot %u Input Context:\n", hdev->slot_id);
+        xhci_dbg_ctx(xhci, config_cmd->in_ctx, 0);
+
+        /* Issue and wait for the configure endpoint or
+         * evaluate context command.
+         */
+        if (xhci->hci_version > 0x95)
+                ret = xhci_configure_endpoint(xhci, hdev, config_cmd,
+                                false, false);
+        else
+                ret = xhci_configure_endpoint(xhci, hdev, config_cmd,
+                                true, false);
+
+        xhci_dbg(xhci, "Slot %u Output Context:\n", hdev->slot_id);
+        xhci_dbg_ctx(xhci, vdev->out_ctx, 0);
+
+        xhci_free_command(xhci, config_cmd);
+        return ret;
+}
+
 int xhci_get_frame(struct usb_hcd *hcd)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index e6b9a1c6002d..1db4fea8c170 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -94,6 +94,9 @@ static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev,
                 val = 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;
         }
         xhci_dbg(xhci, "Linking segment 0x%llx to segment 0x%llx (DMA)\n",
@@ -141,7 +144,6 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
                 return 0;
 
         INIT_LIST_HEAD(&ring->td_list);
-        INIT_LIST_HEAD(&ring->cancelled_td_list);
         if (num_segs == 0)
                 return ring;
 
@@ -262,8 +264,8 @@ void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
                 return;
 
         for (i = 0; i < 31; ++i)
-                if (dev->ep_rings[i])
-                        xhci_ring_free(xhci, dev->ep_rings[i]);
+                if (dev->eps[i].ring)
+                        xhci_ring_free(xhci, dev->eps[i].ring);
 
         if (dev->in_ctx)
                 xhci_free_container_ctx(xhci, dev->in_ctx);
@@ -278,6 +280,7 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
                 struct usb_device *udev, gfp_t flags)
 {
         struct xhci_virt_device *dev;
+        int i;
 
         /* Slot ID 0 is reserved */
         if (slot_id == 0 || xhci->devs[slot_id]) {
@@ -306,12 +309,17 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
         xhci_dbg(xhci, "Slot %d input ctx = 0x%llx (dma)\n", slot_id,
                         (unsigned long long)dev->in_ctx->dma);
 
+        /* Initialize the cancellation list for each endpoint */
+        for (i = 0; i < 31; i++)
+                INIT_LIST_HEAD(&dev->eps[i].cancelled_td_list);
+
         /* Allocate endpoint 0 ring */
-        dev->ep_rings[0] = xhci_ring_alloc(xhci, 1, true, flags);
-        if (!dev->ep_rings[0])
+        dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, flags);
+        if (!dev->eps[0].ring)
                 goto fail;
 
         init_completion(&dev->cmd_completion);
+        INIT_LIST_HEAD(&dev->cmd_list);
 
         /* Point to output device context in dcbaa. */
         xhci->dcbaa->dev_context_ptrs[slot_id] = dev->out_ctx->dma;
@@ -352,9 +360,9 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         /* 3) Only the control endpoint is valid - one endpoint context */
         slot_ctx->dev_info |= LAST_CTX(1);
 
+        slot_ctx->dev_info |= (u32) udev->route;
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-                slot_ctx->dev_info |= (u32) udev->route;
                 slot_ctx->dev_info |= (u32) SLOT_SPEED_SS;
                 break;
         case USB_SPEED_HIGH:
@@ -382,14 +390,12 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         xhci_dbg(xhci, "Set root hub portnum to %d\n", top_dev->portnum);
 
         /* Is this a LS/FS device under a HS hub? */
-        /*
-         * FIXME: I don't think this is right, where does the TT info for the
-         * roothub or parent hub come from?
-         */
         if ((udev->speed == USB_SPEED_LOW || udev->speed == USB_SPEED_FULL) &&
                         udev->tt) {
                 slot_ctx->tt_info = udev->tt->hub->slot_id;
                 slot_ctx->tt_info |= udev->ttport << 8;
+                if (udev->tt->multi)
+                        slot_ctx->dev_info |= DEV_MTT;
         }
         xhci_dbg(xhci, "udev->tt = %p\n", udev->tt);
         xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport);
@@ -398,22 +404,35 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         /* Step 5 */
         ep0_ctx->ep_info2 = EP_TYPE(CTRL_EP);
         /*
-         * See section 4.3 bullet 6:
-         * The default Max Packet size for ep0 is "8 bytes for a USB2
-         * LS/FS/HS device or 512 bytes for a USB3 SS device"
          * XXX: Not sure about wireless USB devices.
          */
-        if (udev->speed == USB_SPEED_SUPER)
+        switch (udev->speed) {
+        case USB_SPEED_SUPER:
                 ep0_ctx->ep_info2 |= MAX_PACKET(512);
-        else
+                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);
+                break;
+        case USB_SPEED_LOW:
                 ep0_ctx->ep_info2 |= MAX_PACKET(8);
+                break;
+        case USB_SPEED_VARIABLE:
+                xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
+                return -EINVAL;
+                break;
+        default:
+                /* New speed? */
+                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->deq =
-                dev->ep_rings[0]->first_seg->dma;
-        ep0_ctx->deq |= dev->ep_rings[0]->cycle_state;
+                dev->eps[0].ring->first_seg->dma;
+        ep0_ctx->deq |= dev->eps[0].ring->cycle_state;
 
         /* Steps 7 and 8 were done in xhci_alloc_virt_device() */
 
@@ -523,10 +542,11 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
         ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index);
 
         /* Set up the endpoint ring */
-        virt_dev->new_ep_rings[ep_index] = xhci_ring_alloc(xhci, 1, true, mem_flags);
-        if (!virt_dev->new_ep_rings[ep_index])
+        virt_dev->eps[ep_index].new_ring =
+                xhci_ring_alloc(xhci, 1, true, mem_flags);
+        if (!virt_dev->eps[ep_index].new_ring)
                 return -ENOMEM;
-        ep_ring = virt_dev->new_ep_rings[ep_index];
+        ep_ring = virt_dev->eps[ep_index].new_ring;
         ep_ctx->deq = ep_ring->first_seg->dma | ep_ring->cycle_state;
 
         ep_ctx->ep_info = xhci_get_endpoint_interval(udev, ep);
@@ -598,6 +618,48 @@ void xhci_endpoint_zero(struct xhci_hcd *xhci,
          */
 }
 
+/* Copy output xhci_ep_ctx to the input xhci_ep_ctx copy.
+ * Useful when you want to change one particular aspect of the endpoint and then
+ * issue a configure endpoint command.
+ */
+void xhci_endpoint_copy(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx,
+                struct xhci_container_ctx *out_ctx,
+                unsigned int ep_index)
+{
+        struct xhci_ep_ctx *out_ep_ctx;
+        struct xhci_ep_ctx *in_ep_ctx;
+
+        out_ep_ctx = xhci_get_ep_ctx(xhci, out_ctx, ep_index);
+        in_ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, ep_index);
+
+        in_ep_ctx->ep_info = out_ep_ctx->ep_info;
+        in_ep_ctx->ep_info2 = out_ep_ctx->ep_info2;
+        in_ep_ctx->deq = out_ep_ctx->deq;
+        in_ep_ctx->tx_info = out_ep_ctx->tx_info;
+}
+
+/* Copy output xhci_slot_ctx to the input xhci_slot_ctx.
+ * Useful when you want to change one particular aspect of the endpoint and then
+ * issue a configure endpoint command.  Only the context entries field matters,
+ * but we'll copy the whole thing anyway.
+ */
+void xhci_slot_copy(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx,
+                struct xhci_container_ctx *out_ctx)
+{
+        struct xhci_slot_ctx *in_slot_ctx;
+        struct xhci_slot_ctx *out_slot_ctx;
+
+        in_slot_ctx = xhci_get_slot_ctx(xhci, in_ctx);
+        out_slot_ctx = xhci_get_slot_ctx(xhci, out_ctx);
+
+        in_slot_ctx->dev_info = out_slot_ctx->dev_info;
+        in_slot_ctx->dev_info2 = out_slot_ctx->dev_info2;
+        in_slot_ctx->tt_info = out_slot_ctx->tt_info;
+        in_slot_ctx->dev_state = out_slot_ctx->dev_state;
+}
+
 /* Set up the scratchpad buffer array and scratchpad buffers, if needed. */
 static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
 {
@@ -695,6 +757,44 @@ static void scratchpad_free(struct xhci_hcd *xhci)
         xhci->scratchpad = NULL;
 }
 
+struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
+                bool allocate_completion, gfp_t mem_flags)
+{
+        struct xhci_command *command;
+
+        command = kzalloc(sizeof(*command), mem_flags);
+        if (!command)
+                return NULL;
+
+        command->in_ctx =
+                xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT, mem_flags);
+        if (!command->in_ctx)
+                return NULL;
+
+        if (allocate_completion) {
+                command->completion =
+                        kzalloc(sizeof(struct completion), mem_flags);
+                if (!command->completion) {
+                        xhci_free_container_ctx(xhci, command->in_ctx);
+                        return NULL;
+                }
+                init_completion(command->completion);
+        }
+
+        command->status = 0;
+        INIT_LIST_HEAD(&command->cmd_list);
+        return command;
+}
+
+void xhci_free_command(struct xhci_hcd *xhci,
+                struct xhci_command *command)
+{
+        xhci_free_container_ctx(xhci,
+                        command->in_ctx);
+        kfree(command->completion);
+        kfree(command);
+}
+
 void xhci_mem_cleanup(struct xhci_hcd *xhci)
 {
         struct pci_dev  *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 592fe7e623f7..06595ec27bb7 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -24,6 +24,10 @@
 
 #include "xhci.h"
 
+/* Device for a quirk */
+#define PCI_VENDOR_ID_FRESCO_LOGIC      0x1b73
+#define PCI_DEVICE_ID_FRESCO_LOGIC_PDK  0x1000
+
 static const char hcd_name[] = "xhci_hcd";
 
 /* called after powerup, by probe or system-pm "wakeup" */
@@ -59,9 +63,20 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
         xhci->hcs_params1 = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);
         xhci->hcs_params2 = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);
         xhci->hcs_params3 = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
+        xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
+        xhci->hci_version = HC_VERSION(xhci->hcc_params);
         xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
         xhci_print_registers(xhci);
 
+        /* Look for vendor-specific quirks */
+        if (pdev->vendor == PCI_VENDOR_ID_FRESCO_LOGIC &&
+                        pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK &&
+                        pdev->revision == 0x0) {
+                        xhci->quirks |= XHCI_RESET_EP_QUIRK;
+                        xhci_dbg(xhci, "QUIRK: Fresco Logic xHC needs configure"
+                                        " endpoint cmd after reset endpoint\n");
+        }
+
         /* Make sure the HC is halted. */
         retval = xhci_halt(xhci);
         if (retval)
@@ -121,6 +136,7 @@ static const struct hc_driver xhci_pci_hc_driver = {
         .check_bandwidth =      xhci_check_bandwidth,
         .reset_bandwidth =      xhci_reset_bandwidth,
         .address_device =       xhci_address_device,
+        .update_hub_device =    xhci_update_hub_device,
 
         /*
          * scheduling support
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index aa88a067148b..173c39c76489 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -172,8 +172,9 @@ static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
  * have their chain bit cleared (so that each Link TRB is a separate TD).
  *
  * Section 6.4.4.1 of the 0.95 spec says link TRBs cannot have the chain bit
- * set, but other sections talk about dealing with the chain bit set.
- * Assume section 6.4.4.1 is wrong, and the chain bit can be set in a Link TRB.
+ * set, but other sections talk about dealing with the chain bit set.  This was
+ * fixed in the 0.96 specification errata, but we have to assume that all 0.95
+ * xHCI hardware can't handle the chain bit being cleared on a link TRB.
  */
 static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer)
 {
@@ -191,8 +192,14 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
         while (last_trb(xhci, ring, ring->enq_seg, next)) {
                 if (!consumer) {
                         if (ring != xhci->event_ring) {
-                                next->link.control &= ~TRB_CHAIN;
-                                next->link.control |= chain;
+                                /* If we're not dealing with 0.95 hardware,
+                                 * carry over the chain bit of the previous TRB
+                                 * (which may mean the chain bit is cleared).
+                                 */
+                                if (!xhci_link_trb_quirk(xhci)) {
+                                        next->link.control &= ~TRB_CHAIN;
+                                        next->link.control |= chain;
+                                }
                                 /* Give this link TRB to the hardware */
                                 wmb();
                                 if (next->link.control & TRB_CYCLE)
@@ -289,16 +296,18 @@ static void ring_ep_doorbell(struct xhci_hcd *xhci,
                 unsigned int slot_id,
                 unsigned int ep_index)
 {
-        struct xhci_ring *ep_ring;
+        struct xhci_virt_ep *ep;
+        unsigned int ep_state;
         u32 field;
         __u32 __iomem *db_addr = &xhci->dba->doorbell[slot_id];
 
-        ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];
+        ep = &xhci->devs[slot_id]->eps[ep_index];
+        ep_state = ep->ep_state;
         /* Don't ring the doorbell for this endpoint if there are pending
          * cancellations because the we don't want to interrupt processing.
          */
-        if (!ep_ring->cancels_pending && !(ep_ring->state & SET_DEQ_PENDING)
-                        && !(ep_ring->state & EP_HALTED)) {
+        if (!ep->cancels_pending && !(ep_state & SET_DEQ_PENDING)
+                        && !(ep_state & EP_HALTED)) {
                 field = xhci_readl(xhci, db_addr) & DB_MASK;
                 xhci_writel(xhci, field | EPI_TO_DB(ep_index), db_addr);
                 /* Flush PCI posted writes - FIXME Matthew Wilcox says this
@@ -354,7 +363,7 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 struct xhci_td *cur_td, struct xhci_dequeue_state *state)
 {
         struct xhci_virt_device *dev = xhci->devs[slot_id];
-        struct xhci_ring *ep_ring = dev->ep_rings[ep_index];
+        struct xhci_ring *ep_ring = dev->eps[ep_index].ring;
         struct xhci_generic_trb *trb;
         struct xhci_ep_ctx *ep_ctx;
         dma_addr_t addr;
@@ -362,7 +371,7 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
         state->new_cycle_state = 0;
         xhci_dbg(xhci, "Finding segment containing stopped TRB.\n");
         state->new_deq_seg = find_trb_seg(cur_td->start_seg,
-                        ep_ring->stopped_trb,
+                        dev->eps[ep_index].stopped_trb,
                         &state->new_cycle_state);
         if (!state->new_deq_seg)
                 BUG();
@@ -442,9 +451,11 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
                 union xhci_trb *deq_ptr, u32 cycle_state);
 
 void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
-                struct xhci_ring *ep_ring, unsigned int slot_id,
-                unsigned int ep_index, struct xhci_dequeue_state *deq_state)
+                unsigned int slot_id, unsigned int ep_index,
+                struct xhci_dequeue_state *deq_state)
 {
+        struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
+
         xhci_dbg(xhci, "Set TR Deq Ptr cmd, new deq seg = %p (0x%llx dma), "
                         "new deq ptr = %p (0x%llx dma), new cycle = %u\n",
                         deq_state->new_deq_seg,
@@ -461,8 +472,7 @@ void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
          * if the ring is running, and ringing the doorbell starts the
          * ring running.
          */
-        ep_ring->state |= SET_DEQ_PENDING;
-        xhci_ring_cmd_db(xhci);
+        ep->ep_state |= SET_DEQ_PENDING;
 }
 
 /*
@@ -481,6 +491,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
         unsigned int slot_id;
         unsigned int ep_index;
         struct xhci_ring *ep_ring;
+        struct xhci_virt_ep *ep;
         struct list_head *entry;
         struct xhci_td *cur_td = 0;
         struct xhci_td *last_unlinked_td;
@@ -493,9 +504,10 @@ 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]);
-        ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];
+        ep = &xhci->devs[slot_id]->eps[ep_index];
+        ep_ring = ep->ring;
 
-        if (list_empty(&ep_ring->cancelled_td_list))
+        if (list_empty(&ep->cancelled_td_list))
                 return;
 
         /* Fix up the ep ring first, so HW stops executing cancelled TDs.
@@ -503,7 +515,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
          * it.  We're also in the event handler, so we can't get re-interrupted
          * if another Stop Endpoint command completes
          */
-        list_for_each(entry, &ep_ring->cancelled_td_list) {
+        list_for_each(entry, &ep->cancelled_td_list) {
                 cur_td = list_entry(entry, struct xhci_td, cancelled_td_list);
                 xhci_dbg(xhci, "Cancelling TD starting at %p, 0x%llx (dma).\n",
                                 cur_td->first_trb,
@@ -512,7 +524,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
                  * If we stopped on the TD we need to cancel, then we have to
                  * move the xHC endpoint ring dequeue pointer past this TD.
                  */
-                if (cur_td == ep_ring->stopped_td)
+                if (cur_td == ep->stopped_td)
                         xhci_find_new_dequeue_state(xhci, slot_id, ep_index, cur_td,
                                         &deq_state);
                 else
@@ -523,14 +535,15 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
                  * the cancelled TD list for URB completion later.
                  */
                 list_del(&cur_td->td_list);
-                ep_ring->cancels_pending--;
+                ep->cancels_pending--;
         }
         last_unlinked_td = cur_td;
 
         /* If necessary, queue a Set Transfer Ring Dequeue Pointer command */
         if (deq_state.new_deq_ptr && deq_state.new_deq_seg) {
-                xhci_queue_new_dequeue_state(xhci, ep_ring,
+                xhci_queue_new_dequeue_state(xhci,
                                 slot_id, ep_index, &deq_state);
+                xhci_ring_cmd_db(xhci);
         } else {
                 /* Otherwise just ring the doorbell to restart the ring */
                 ring_ep_doorbell(xhci, slot_id, ep_index);
@@ -543,7 +556,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
          * So stop when we've completed the URB for the last TD we unlinked.
          */
         do {
-                cur_td = list_entry(ep_ring->cancelled_td_list.next,
+                cur_td = list_entry(ep->cancelled_td_list.next,
                                 struct xhci_td, cancelled_td_list);
                 list_del(&cur_td->cancelled_td_list);
 
@@ -590,7 +603,7 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
         slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
         ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
         dev = xhci->devs[slot_id];
-        ep_ring = dev->ep_rings[ep_index];
+        ep_ring = dev->eps[ep_index].ring;
         ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
         slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx);
 
@@ -634,7 +647,7 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
                                 ep_ctx->deq);
         }
 
-        ep_ring->state &= ~SET_DEQ_PENDING;
+        dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING;
         ring_ep_doorbell(xhci, slot_id, ep_index);
 }
 
@@ -644,18 +657,60 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci,
 {
         int slot_id;
         unsigned int ep_index;
+        struct xhci_ring *ep_ring;
 
         slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
         ep_index = TRB_TO_EP_INDEX(trb->generic.field[3]);
+        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
         /* 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));
 
-        /* Clear our internal halted state and restart the ring */
-        xhci->devs[slot_id]->ep_rings[ep_index]->state &= ~EP_HALTED;
-        ring_ep_doorbell(xhci, slot_id, ep_index);
+        /* HW with the reset endpoint quirk needs to have a configure endpoint
+         * command complete before the endpoint can be used.  Queue that here
+         * because the HW can't handle two commands being queued in a row.
+         */
+        if (xhci->quirks & XHCI_RESET_EP_QUIRK) {
+                xhci_dbg(xhci, "Queueing configure endpoint command\n");
+                xhci_queue_configure_endpoint(xhci,
+                                xhci->devs[slot_id]->in_ctx->dma, slot_id,
+                                false);
+                xhci_ring_cmd_db(xhci);
+        } else {
+                /* Clear our internal halted state and restart the ring */
+                xhci->devs[slot_id]->eps[ep_index].ep_state &= ~EP_HALTED;
+                ring_ep_doorbell(xhci, slot_id, ep_index);
+        }
+}
+
+/* Check to see if a command in the device's command queue matches this one.
+ * Signal the completion or free the command, and return 1.  Return 0 if the
+ * completed command isn't at the head of the command list.
+ */
+static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                struct xhci_event_cmd *event)
+{
+        struct xhci_command *command;
+
+        if (list_empty(&virt_dev->cmd_list))
+                return 0;
+
+        command = list_entry(virt_dev->cmd_list.next,
+                        struct xhci_command, cmd_list);
+        if (xhci->cmd_ring->dequeue != command->command_trb)
+                return 0;
+
+        command->status =
+                GET_COMP_CODE(event->status);
+        list_del(&command->cmd_list);
+        if (command->completion)
+                complete(command->completion);
+        else
+                xhci_free_command(xhci, command);
+        return 1;
 }
 
 static void handle_cmd_completion(struct xhci_hcd *xhci,
@@ -664,6 +719,11 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
         int slot_id = TRB_TO_SLOT_ID(event->flags);
         u64 cmd_dma;
         dma_addr_t cmd_dequeue_dma;
+        struct xhci_input_control_ctx *ctrl_ctx;
+        struct xhci_virt_device *virt_dev;
+        unsigned int ep_index;
+        struct xhci_ring *ep_ring;
+        unsigned int ep_state;
 
         cmd_dma = event->cmd_trb;
         cmd_dequeue_dma = xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
@@ -691,6 +751,47 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                         xhci_free_virt_device(xhci, slot_id);
                 break;
         case TRB_TYPE(TRB_CONFIG_EP):
+                virt_dev = xhci->devs[slot_id];
+                if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
+                        break;
+                /*
+                 * Configure endpoint commands can come from the USB core
+                 * configuration or alt setting changes, or because the HW
+                 * needed an extra configure endpoint command after a reset
+                 * endpoint command.  In the latter case, the xHCI driver is
+                 * not waiting on the configure endpoint command.
+                 */
+                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_ring = xhci->devs[slot_id]->eps[ep_index].ring;
+                if (!ep_ring) {
+                        /* This must have been an initial configure endpoint */
+                        xhci->devs[slot_id]->cmd_status =
+                                GET_COMP_CODE(event->status);
+                        complete(&xhci->devs[slot_id]->cmd_completion);
+                        break;
+                }
+                ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;
+                xhci_dbg(xhci, "Completed config ep cmd - last ep index = %d, "
+                                "state = %d\n", ep_index, ep_state);
+                if (xhci->quirks & XHCI_RESET_EP_QUIRK &&
+                                ep_state & EP_HALTED) {
+                        /* Clear our internal halted state and restart ring */
+                        xhci->devs[slot_id]->eps[ep_index].ep_state &=
+                                ~EP_HALTED;
+                        ring_ep_doorbell(xhci, slot_id, ep_index);
+                } else {
+                        xhci->devs[slot_id]->cmd_status =
+                                GET_COMP_CODE(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);
                 complete(&xhci->devs[slot_id]->cmd_completion);
                 break;
@@ -805,7 +906,9 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 struct xhci_transfer_event *event)
 {
         struct xhci_virt_device *xdev;
+        struct xhci_virt_ep *ep;
         struct xhci_ring *ep_ring;
+        unsigned int slot_id;
         int ep_index;
         struct xhci_td *td = 0;
         dma_addr_t event_dma;
@@ -814,9 +917,11 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         struct urb *urb = 0;
         int status = -EINPROGRESS;
         struct xhci_ep_ctx *ep_ctx;
+        u32 trb_comp_code;
 
         xhci_dbg(xhci, "In %s\n", __func__);
-        xdev = xhci->devs[TRB_TO_SLOT_ID(event->flags)];
+        slot_id = TRB_TO_SLOT_ID(event->flags);
+        xdev = xhci->devs[slot_id];
         if (!xdev) {
                 xhci_err(xhci, "ERROR Transfer event pointed to bad slot\n");
                 return -ENODEV;
@@ -825,7 +930,8 @@ 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;
         xhci_dbg(xhci, "%s - ep index = %d\n", __func__, ep_index);
-        ep_ring = xdev->ep_rings[ep_index];
+        ep = &xdev->eps[ep_index];
+        ep_ring = ep->ring;
         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) {
                 xhci_err(xhci, "ERROR Transfer event pointed to disabled endpoint\n");
@@ -870,7 +976,8 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         (unsigned int) event->flags);
 
         /* Look for common error cases */
-        switch (GET_COMP_CODE(event->transfer_len)) {
+        trb_comp_code = GET_COMP_CODE(event->transfer_len);
+        switch (trb_comp_code) {
         /* Skip codes that require special handling depending on
          * transfer type
          */
@@ -885,7 +992,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 break;
         case COMP_STALL:
                 xhci_warn(xhci, "WARN: Stalled endpoint\n");
-                ep_ring->state |= EP_HALTED;
+                ep->ep_state |= EP_HALTED;
                 status = -EPIPE;
                 break;
         case COMP_TRB_ERR:
@@ -913,7 +1020,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
         /* Was this a control transfer? */
         if (usb_endpoint_xfer_control(&td->urb->ep->desc)) {
                 xhci_debug_trb(xhci, xhci->event_ring->dequeue);
-                switch (GET_COMP_CODE(event->transfer_len)) {
+                switch (trb_comp_code) {
                 case COMP_SUCCESS:
                         if (event_trb == ep_ring->dequeue) {
                                 xhci_warn(xhci, "WARN: Success on ctrl setup TRB without IOC set??\n");
@@ -928,8 +1035,37 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         break;
                 case COMP_SHORT_TX:
                         xhci_warn(xhci, "WARN: short transfer on control ep\n");
-                        status = -EREMOTEIO;
+                        if (td->urb->transfer_flags & URB_SHORT_NOT_OK)
+                                status = -EREMOTEIO;
+                        else
+                                status = 0;
                         break;
+                case COMP_BABBLE:
+                        /* The 0.96 spec says a babbling control endpoint
+                         * is not halted. The 0.96 spec says it is.  Some HW
+                         * claims to be 0.95 compliant, but it halts the control
+                         * endpoint anyway.  Check if a babble halted the
+                         * endpoint.
+                         */
+                        if (ep_ctx->ep_info != EP_STATE_HALTED)
+                                break;
+                        /* else fall through */
+                case COMP_STALL:
+                        /* Did we transfer part of the data (middle) phase? */
+                        if (event_trb != ep_ring->dequeue &&
+                                        event_trb != td->last_trb)
+                                td->urb->actual_length =
+                                        td->urb->transfer_buffer_length
+                                        - TRB_LEN(event->transfer_len);
+                        else
+                                td->urb->actual_length = 0;
+
+                        ep->stopped_td = td;
+                        ep->stopped_trb = event_trb;
+                        xhci_queue_reset_ep(xhci, slot_id, ep_index);
+                        xhci_cleanup_stalled_ring(xhci, td->urb->dev, ep_index);
+                        xhci_ring_cmd_db(xhci);
+                        goto td_cleanup;
                 default:
                         /* Others already handled above */
                         break;
@@ -943,7 +1079,10 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         if (event_trb == td->last_trb) {
                                 if (td->urb->actual_length != 0) {
                                         /* Don't overwrite a previously set error code */
-                                        if (status == -EINPROGRESS || status == 0)
+                                        if ((status == -EINPROGRESS ||
+                                                                status == 0) &&
+                                                        (td->urb->transfer_flags
+                                                         & URB_SHORT_NOT_OK))
                                                 /* Did we already see a short data stage? */
                                                 status = -EREMOTEIO;
                                 } else {
@@ -952,7 +1091,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                                 }
                         } else {
                         /* Maybe the event was for the data stage? */
-                                if (GET_COMP_CODE(event->transfer_len) != COMP_STOP_INVAL) {
+                                if (trb_comp_code != COMP_STOP_INVAL) {
                                         /* We didn't stop on a link TRB in the middle */
                                         td->urb->actual_length =
                                                 td->urb->transfer_buffer_length -
@@ -964,7 +1103,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         }
                 }
         } else {
-                switch (GET_COMP_CODE(event->transfer_len)) {
+                switch (trb_comp_code) {
                 case COMP_SUCCESS:
                         /* Double check that the HW transferred everything. */
                         if (event_trb != td->last_trb) {
@@ -975,7 +1114,12 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                                 else
                                         status = 0;
                         } else {
-                                xhci_dbg(xhci, "Successful bulk transfer!\n");
+                                if (usb_endpoint_xfer_bulk(&td->urb->ep->desc))
+                                        xhci_dbg(xhci, "Successful bulk "
+                                                        "transfer!\n");
+                                else
+                                        xhci_dbg(xhci, "Successful interrupt "
+                                                        "transfer!\n");
                                 status = 0;
                         }
                         break;
@@ -1001,11 +1145,17 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                                 td->urb->actual_length =
                                         td->urb->transfer_buffer_length -
                                         TRB_LEN(event->transfer_len);
-                                if (td->urb->actual_length < 0) {
+                                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));
                                         td->urb->actual_length = 0;
+                                        if (td->urb->transfer_flags &
+                                                        URB_SHORT_NOT_OK)
+                                                status = -EREMOTEIO;
+                                        else
+                                                status = 0;
                                 }
                                 /* Don't overwrite a previously set error code */
                                 if (status == -EINPROGRESS) {
@@ -1041,30 +1191,31 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         /* If the ring didn't stop on a Link or No-op TRB, add
                          * in the actual bytes transferred from the Normal TRB
                          */
-                        if (GET_COMP_CODE(event->transfer_len) != COMP_STOP_INVAL)
+                        if (trb_comp_code != COMP_STOP_INVAL)
                                 td->urb->actual_length +=
                                         TRB_LEN(cur_trb->generic.field[2]) -
                                         TRB_LEN(event->transfer_len);
                 }
         }
-        if (GET_COMP_CODE(event->transfer_len) == COMP_STOP_INVAL ||
-                        GET_COMP_CODE(event->transfer_len) == COMP_STOP) {
+        if (trb_comp_code == COMP_STOP_INVAL ||
+                        trb_comp_code == COMP_STOP) {
                 /* The Endpoint Stop Command completion will take care of any
                  * stopped TDs.  A stopped TD may be restarted, so don't update
                  * the ring dequeue pointer or take this TD off any lists yet.
                  */
-                ep_ring->stopped_td = td;
-                ep_ring->stopped_trb = event_trb;
+                ep->stopped_td = td;
+                ep->stopped_trb = event_trb;
         } else {
-                if (GET_COMP_CODE(event->transfer_len) == COMP_STALL) {
+                if (trb_comp_code == COMP_STALL ||
+                                trb_comp_code == COMP_BABBLE) {
                         /* The transfer is completed from the driver's
                          * perspective, but we need to issue a set dequeue
                          * command for this stalled endpoint to move the dequeue
                          * pointer past the TD.  We can't do that here because
                          * the halt condition must be cleared first.
                          */
-                        ep_ring->stopped_td = td;
-                        ep_ring->stopped_trb = event_trb;
+                        ep->stopped_td = td;
+                        ep->stopped_trb = event_trb;
                 } else {
                         /* Update ring dequeue pointer */
                         while (ep_ring->dequeue != td->last_trb)
@@ -1072,16 +1223,41 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         inc_deq(xhci, ep_ring, false);
                 }
 
+td_cleanup:
                 /* Clean up the endpoint's TD list */
                 urb = td->urb;
+                /* Do one last check of the actual transfer length.
+                 * If the host controller said we transferred more data than
+                 * the buffer length, urb->actual_length will be a very big
+                 * number (since it's unsigned).  Play it safe and say we didn't
+                 * transfer anything.
+                 */
+                if (urb->actual_length > urb->transfer_buffer_length) {
+                        xhci_warn(xhci, "URB transfer length is wrong, "
+                                        "xHC issue? req. len = %u, "
+                                        "act. len = %u\n",
+                                        urb->transfer_buffer_length,
+                                        urb->actual_length);
+                        urb->actual_length = 0;
+                        if (td->urb->transfer_flags & URB_SHORT_NOT_OK)
+                                status = -EREMOTEIO;
+                        else
+                                status = 0;
+                }
                 list_del(&td->td_list);
                 /* Was this TD slated to be cancelled but completed anyway? */
                 if (!list_empty(&td->cancelled_td_list)) {
                         list_del(&td->cancelled_td_list);
-                        ep_ring->cancels_pending--;
+                        ep->cancels_pending--;
                 }
-                /* Leave the TD around for the reset endpoint function to use */
-                if (GET_COMP_CODE(event->transfer_len) != COMP_STALL) {
+                /* Leave the TD around for the reset endpoint function to use
+                 * (but only if it's not a control endpoint, since we already
+                 * queued the Set TR dequeue pointer command for stalled
+                 * control endpoints).
+                 */
+                if (usb_endpoint_xfer_control(&urb->ep->desc) ||
+                        (trb_comp_code != COMP_STALL &&
+                                trb_comp_code != COMP_BABBLE)) {
                         kfree(td);
                 }
                 urb->hcpriv = NULL;
@@ -1094,7 +1270,7 @@ cleanup:
         if (urb) {
                 usb_hcd_unlink_urb_from_ep(xhci_to_hcd(xhci), urb);
                 xhci_dbg(xhci, "Giveback URB %p, len = %d, status = %d\n",
-                                urb, td->urb->actual_length, status);
+                                urb, urb->actual_length, status);
                 spin_unlock(&xhci->lock);
                 usb_hcd_giveback_urb(xhci_to_hcd(xhci), urb, status);
                 spin_lock(&xhci->lock);
@@ -1235,7 +1411,7 @@ static int prepare_transfer(struct xhci_hcd *xhci,
 {
         int ret;
         struct xhci_ep_ctx *ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
-        ret = prepare_ring(xhci, xdev->ep_rings[ep_index],
+        ret = prepare_ring(xhci, xdev->eps[ep_index].ring,
                         ep_ctx->ep_info & EP_STATE_MASK,
                         num_trbs, mem_flags);
         if (ret)
@@ -1255,9 +1431,9 @@ static int prepare_transfer(struct xhci_hcd *xhci,
         (*td)->urb = urb;
         urb->hcpriv = (void *) (*td);
         /* Add this TD to the tail of the endpoint ring's TD list */
-        list_add_tail(&(*td)->td_list, &xdev->ep_rings[ep_index]->td_list);
-        (*td)->start_seg = xdev->ep_rings[ep_index]->enq_seg;
-        (*td)->first_trb = xdev->ep_rings[ep_index]->enqueue;
+        list_add_tail(&(*td)->td_list, &xdev->eps[ep_index].ring->td_list);
+        (*td)->start_seg = xdev->eps[ep_index].ring->enq_seg;
+        (*td)->first_trb = xdev->eps[ep_index].ring->enqueue;
 
         return 0;
 }
@@ -1335,6 +1511,47 @@ static void giveback_first_trb(struct xhci_hcd *xhci, int slot_id,
         ring_ep_doorbell(xhci, slot_id, ep_index);
 }
 
+/*
+ * xHCI uses normal TRBs for both bulk and interrupt.  When the interrupt
+ * endpoint is to be serviced, the xHC will consume (at most) one TD.  A TD
+ * (comprised of sg list entries) can take several service intervals to
+ * transmit.
+ */
+int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
+                struct urb *urb, int slot_id, unsigned int ep_index)
+{
+        struct xhci_ep_ctx *ep_ctx = xhci_get_ep_ctx(xhci,
+                        xhci->devs[slot_id]->out_ctx, ep_index);
+        int xhci_interval;
+        int ep_interval;
+
+        xhci_interval = EP_INTERVAL_TO_UFRAMES(ep_ctx->ep_info);
+        ep_interval = urb->interval;
+        /* Convert to microframes */
+        if (urb->dev->speed == USB_SPEED_LOW ||
+                        urb->dev->speed == USB_SPEED_FULL)
+                ep_interval *= 8;
+        /* FIXME change this to a warning and a suggestion to use the new API
+         * to set the polling interval (once the API is added).
+         */
+        if (xhci_interval != ep_interval) {
+                if (!printk_ratelimit())
+                        dev_dbg(&urb->dev->dev, "Driver uses different interval"
+                                        " (%d microframe%s) than xHCI "
+                                        "(%d microframe%s)\n",
+                                        ep_interval,
+                                        ep_interval == 1 ? "" : "s",
+                                        xhci_interval,
+                                        xhci_interval == 1 ? "" : "s");
+                urb->interval = xhci_interval;
+                /* Convert back to frames for LS/FS devices */
+                if (urb->dev->speed == USB_SPEED_LOW ||
+                                urb->dev->speed == USB_SPEED_FULL)
+                        urb->interval /= 8;
+        }
+        return xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb, slot_id, ep_index);
+}
+
 static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 struct urb *urb, int slot_id, unsigned int ep_index)
 {
@@ -1350,7 +1567,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         struct xhci_generic_trb *start_trb;
         int start_cycle;
 
-        ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];
+        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
         num_trbs = count_sg_trbs_needed(xhci, urb);
         num_sgs = urb->num_sgs;
 
@@ -1483,7 +1700,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         if (urb->sg)
                 return queue_bulk_sg_tx(xhci, mem_flags, urb, slot_id, ep_index);
 
-        ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];
+        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
 
         num_trbs = 0;
         /* How much data is (potentially) left before the 64KB boundary? */
@@ -1594,7 +1811,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         u32 field, length_field;
         struct xhci_td *td;
 
-        ep_ring = xhci->devs[slot_id]->ep_rings[ep_index];
+        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
 
         /*
          * Need to copy setup packet into setup TRB, so we can't use the setup
@@ -1677,12 +1894,27 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
 /****           Command Ring Operations         ****/
 
-/* Generic function for queueing a command TRB on the command ring */
-static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2, u32 field3, u32 field4)
+/* Generic function for queueing a command TRB on the command ring.
+ * Check to make sure there's room on the command ring for one command TRB.
+ * Also check that there's room reserved for commands that must not fail.
+ * If this is a command that must not fail, meaning command_must_succeed = TRUE,
+ * then only check for the number of reserved spots.
+ * Don't decrement xhci->cmd_ring_reserved_trbs after we've queued the TRB
+ * because the command event handler may want to resubmit a failed command.
+ */
+static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
+                u32 field3, u32 field4, bool command_must_succeed)
 {
-        if (!room_on_ring(xhci, xhci->cmd_ring, 1)) {
+        int reserved_trbs = xhci->cmd_ring_reserved_trbs;
+        if (!command_must_succeed)
+                reserved_trbs++;
+
+        if (!room_on_ring(xhci, xhci->cmd_ring, reserved_trbs)) {
                 if (!in_interrupt())
                         xhci_err(xhci, "ERR: No room for command on command ring\n");
+                if (command_must_succeed)
+                        xhci_err(xhci, "ERR: Reserved TRB counting for "
+                                        "unfailable commands failed.\n");
                 return -ENOMEM;
         }
         queue_trb(xhci, xhci->cmd_ring, false, field1, field2, field3,
@@ -1693,7 +1925,7 @@ static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2, u32 fiel
 /* Queue a no-op command on the command ring */
 static int queue_cmd_noop(struct xhci_hcd *xhci)
 {
-        return queue_command(xhci, 0, 0, 0, TRB_TYPE(TRB_CMD_NOOP));
+        return queue_command(xhci, 0, 0, 0, TRB_TYPE(TRB_CMD_NOOP), false);
 }
 
 /*
@@ -1712,7 +1944,7 @@ void *xhci_setup_one_noop(struct xhci_hcd *xhci)
 int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id)
 {
         return queue_command(xhci, 0, 0, 0,
-                        TRB_TYPE(trb_type) | SLOT_ID_FOR_TRB(slot_id));
+                        TRB_TYPE(trb_type) | SLOT_ID_FOR_TRB(slot_id), false);
 }
 
 /* Queue an address device command TRB */
@@ -1721,16 +1953,28 @@ int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
 {
         return queue_command(xhci, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
-                        TRB_TYPE(TRB_ADDR_DEV) | SLOT_ID_FOR_TRB(slot_id));
+                        TRB_TYPE(TRB_ADDR_DEV) | SLOT_ID_FOR_TRB(slot_id),
+                        false);
 }
 
 /* Queue a configure endpoint command TRB */
 int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
+                u32 slot_id, bool command_must_succeed)
+{
+        return queue_command(xhci, lower_32_bits(in_ctx_ptr),
+                        upper_32_bits(in_ctx_ptr), 0,
+                        TRB_TYPE(TRB_CONFIG_EP) | SLOT_ID_FOR_TRB(slot_id),
+                        command_must_succeed);
+}
+
+/* Queue an evaluate context command TRB */
+int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
                 u32 slot_id)
 {
         return queue_command(xhci, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
-                        TRB_TYPE(TRB_CONFIG_EP) | SLOT_ID_FOR_TRB(slot_id));
+                        TRB_TYPE(TRB_EVAL_CONTEXT) | SLOT_ID_FOR_TRB(slot_id),
+                        false);
 }
 
 int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
@@ -1741,7 +1985,7 @@ int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
         u32 type = TRB_TYPE(TRB_STOP_RING);
 
         return queue_command(xhci, 0, 0, 0,
-                        trb_slot_id | trb_ep_index | type);
+                        trb_slot_id | trb_ep_index | type, false);
 }
 
 /* Set Transfer Ring Dequeue Pointer command.
@@ -1765,7 +2009,7 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
         }
         return queue_command(xhci, lower_32_bits(addr) | cycle_state,
                         upper_32_bits(addr), 0,
-                        trb_slot_id | trb_ep_index | type);
+                        trb_slot_id | trb_ep_index | type, false);
 }
 
 int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
@@ -1775,5 +2019,6 @@ int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
         u32 trb_ep_index = EP_ID_FOR_TRB(ep_index);
         u32 type = TRB_TYPE(TRB_RESET_EP);
 
-        return queue_command(xhci, 0, 0, 0, trb_slot_id | trb_ep_index | type);
+        return queue_command(xhci, 0, 0, 0, trb_slot_id | trb_ep_index | type,
+                        false);
 }
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index ffe1625d4e1b..4b254b6fa245 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -509,6 +509,8 @@ struct xhci_slot_ctx {
 #define MAX_EXIT        (0xffff)
 /* Root hub port number that is needed to access the USB device */
 #define ROOT_HUB_PORT(p)        (((p) & 0xff) << 16)
+/* Maximum number of ports under a hub device */
+#define XHCI_MAX_PORTS(p)       (((p) & 0xff) << 24)
 
 /* tt_info bitmasks */
 /*
@@ -522,6 +524,7 @@ struct xhci_slot_ctx {
  * '0' if the device is not low or full speed.
  */
 #define TT_PORT         (0xff << 8)
+#define TT_THINK_TIME(p)        (((p) & 0x3) << 16)
 
 /* dev_state bitmasks */
 /* USB device address - assigned by the HC */
@@ -581,6 +584,7 @@ struct xhci_ep_ctx {
 /* bit 15 is Linear Stream Array */
 /* Interval - period between requests to an endpoint - 125u increments. */
 #define EP_INTERVAL(p)          ((p & 0xff) << 16)
+#define EP_INTERVAL_TO_UFRAMES(p)               (1 << (((p) >> 16) & 0xff))
 
 /* ep_info2 bitmasks */
 /*
@@ -589,6 +593,7 @@ struct xhci_ep_ctx {
  */
 #define FORCE_EVENT     (0x1)
 #define ERROR_COUNT(p)  (((p) & 0x3) << 1)
+#define CTX_TO_EP_TYPE(p)       (((p) >> 3) & 0x7)
 #define EP_TYPE(p)      ((p) << 3)
 #define ISOC_OUT_EP     1
 #define BULK_OUT_EP     2
@@ -601,6 +606,8 @@ struct xhci_ep_ctx {
 /* bit 7 is Host Initiate Disable - for disabling stream selection */
 #define MAX_BURST(p)    (((p)&0xff) << 8)
 #define MAX_PACKET(p)   (((p)&0xffff) << 16)
+#define MAX_PACKET_MASK         (0xffff << 16)
+#define MAX_PACKET_DECODED(p)   (((p) >> 16) & 0xffff)
 
 
 /**
@@ -616,11 +623,44 @@ struct xhci_input_control_ctx {
         u32     rsvd2[6];
 };
 
+/* Represents everything that is needed to issue a command on the command ring.
+ * It's useful to pre-allocate these for commands that cannot fail due to
+ * out-of-memory errors, like freeing streams.
+ */
+struct xhci_command {
+        /* Input context for changing device state */
+        struct xhci_container_ctx       *in_ctx;
+        u32                             status;
+        /* If completion is null, no one is waiting on this command
+         * and the structure can be freed after the command completes.
+         */
+        struct completion               *completion;
+        union xhci_trb                  *command_trb;
+        struct list_head                cmd_list;
+};
+
 /* drop context bitmasks */
 #define DROP_EP(x)      (0x1 << x)
 /* add context bitmasks */
 #define ADD_EP(x)       (0x1 << x)
 
+struct xhci_virt_ep {
+        struct xhci_ring                *ring;
+        /* Temporary storage in case the configure endpoint command fails and we
+         * have to restore the device state to the previous state
+         */
+        struct xhci_ring                *new_ring;
+        unsigned int                    ep_state;
+#define SET_DEQ_PENDING         (1 << 0)
+#define EP_HALTED               (1 << 1)
+        /* ----  Related to URB cancellation ---- */
+        struct list_head        cancelled_td_list;
+        unsigned int            cancels_pending;
+        /* The TRB that was last reported in a stopped endpoint ring */
+        union xhci_trb          *stopped_trb;
+        struct xhci_td          *stopped_td;
+};
+
 struct xhci_virt_device {
         /*
          * Commands to the hardware are passed an "input context" that
@@ -633,16 +673,11 @@ struct xhci_virt_device {
         struct xhci_container_ctx       *out_ctx;
         /* Used for addressing devices and configuration changes */
         struct xhci_container_ctx       *in_ctx;
-
-        /* FIXME when stream support is added */
-        struct xhci_ring                *ep_rings[31];
-        /* Temporary storage in case the configure endpoint command fails and we
-         * have to restore the device state to the previous state
-         */
-        struct xhci_ring                *new_ep_rings[31];
+        struct xhci_virt_ep             eps[31];
         struct completion               cmd_completion;
         /* Status of the last command issued for this device */
         u32                             cmd_status;
+        struct list_head                cmd_list;
 };
 
 
@@ -905,6 +940,8 @@ union xhci_trb {
  * It must also be greater than 16.
  */
 #define TRBS_PER_SEGMENT        64
+/* Allow two commands + a link TRB, along with any reserved command TRBs */
+#define MAX_RSVD_CMD_TRBS       (TRBS_PER_SEGMENT - 3)
 #define SEGMENT_SIZE            (TRBS_PER_SEGMENT*16)
 /* TRB buffer pointers can't cross 64KB boundaries */
 #define TRB_MAX_BUFF_SHIFT              16
@@ -926,6 +963,12 @@ struct xhci_td {
         union xhci_trb          *last_trb;
 };
 
+struct xhci_dequeue_state {
+        struct xhci_segment *new_deq_seg;
+        union xhci_trb *new_deq_ptr;
+        int new_cycle_state;
+};
+
 struct xhci_ring {
         struct xhci_segment     *first_seg;
         union  xhci_trb         *enqueue;
@@ -935,15 +978,6 @@ struct xhci_ring {
         struct xhci_segment     *deq_seg;
         unsigned int            deq_updates;
         struct list_head        td_list;
-        /* ----  Related to URB cancellation ---- */
-        struct list_head        cancelled_td_list;
-        unsigned int            cancels_pending;
-        unsigned int            state;
-#define SET_DEQ_PENDING         (1 << 0)
-#define EP_HALTED               (1 << 1)
-        /* The TRB that was last reported in a stopped endpoint ring */
-        union xhci_trb          *stopped_trb;
-        struct xhci_td          *stopped_td;
         /*
          * Write the cycle state into the TRB cycle field to give ownership of
          * the TRB to the host controller (if we are the producer), or to check
@@ -952,12 +986,6 @@ struct xhci_ring {
         u32                     cycle_state;
 };
 
-struct xhci_dequeue_state {
-        struct xhci_segment *new_deq_seg;
-        union xhci_trb *new_deq_ptr;
-        int new_cycle_state;
-};
-
 struct xhci_erst_entry {
         /* 64-bit event ring segment address */
         u64     seg_addr;
@@ -1034,6 +1062,7 @@ struct xhci_hcd {
         /* data structures */
         struct xhci_device_context_array *dcbaa;
         struct xhci_ring        *cmd_ring;
+        unsigned int            cmd_ring_reserved_trbs;
         struct xhci_ring        *event_ring;
         struct xhci_erst        erst;
         /* Scratchpad */
@@ -1058,6 +1087,9 @@ struct xhci_hcd {
         int                     noops_submitted;
         int                     noops_handled;
         int                     error_bitmask;
+        unsigned int            quirks;
+#define XHCI_LINK_TRB_QUIRK     (1 << 0)
+#define XHCI_RESET_EP_QUIRK     (1 << 1)
 };
 
 /* For testing purposes */
@@ -1136,6 +1168,13 @@ static inline void xhci_write_64(struct xhci_hcd *xhci,
         writel(val_hi, ptr + 1);
 }
 
+static inline int xhci_link_trb_quirk(struct xhci_hcd *xhci)
+{
+        u32 temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
+        return ((HC_VERSION(temp) == 0x95) &&
+                        (xhci->quirks & XHCI_LINK_TRB_QUIRK));
+}
+
 /* xHCI debugging */
 void xhci_print_ir_set(struct xhci_hcd *xhci, struct xhci_intr_reg *ir_set, int set_num);
 void xhci_print_registers(struct xhci_hcd *xhci);
@@ -1158,11 +1197,24 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, struct usb_device
 int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *udev);
 unsigned int xhci_get_endpoint_index(struct usb_endpoint_descriptor *desc);
 unsigned int xhci_get_endpoint_flag(struct usb_endpoint_descriptor *desc);
+unsigned int xhci_get_endpoint_flag_from_index(unsigned int ep_index);
+unsigned int xhci_last_valid_endpoint(u32 added_ctxs);
 void xhci_endpoint_zero(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, struct usb_host_endpoint *ep);
+void xhci_endpoint_copy(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx,
+                struct xhci_container_ctx *out_ctx,
+                unsigned int ep_index);
+void xhci_slot_copy(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx,
+                struct xhci_container_ctx *out_ctx);
 int xhci_endpoint_init(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev,
                 struct usb_device *udev, struct usb_host_endpoint *ep,
                 gfp_t mem_flags);
 void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring);
+struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
+                bool allocate_completion, gfp_t mem_flags);
+void xhci_free_command(struct xhci_hcd *xhci,
+                struct xhci_command *command);
 
 #ifdef CONFIG_PCI
 /* xHCI PCI glue */
@@ -1182,6 +1234,8 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd);
 int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev);
 void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev);
 int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev);
+int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
+                        struct usb_tt *tt, gfp_t mem_flags);
 int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags);
 int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status);
 int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep);
@@ -1205,7 +1259,11 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
                 int slot_id, unsigned int ep_index);
 int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
                 int slot_id, unsigned int ep_index);
+int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
+                int slot_id, unsigned int ep_index);
 int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
+                u32 slot_id, bool command_must_succeed);
+int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
                 u32 slot_id);
 int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
                 unsigned int ep_index);
@@ -1213,8 +1271,13 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 struct xhci_td *cur_td, struct xhci_dequeue_state *state);
 void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
-                struct xhci_ring *ep_ring, unsigned int slot_id,
-                unsigned int ep_index, struct xhci_dequeue_state *deq_state);
+                unsigned int slot_id, unsigned int ep_index,
+                struct xhci_dequeue_state *deq_state);
+void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
+                struct usb_device *udev, unsigned int ep_index);
+void xhci_queue_config_ep_quirk(struct xhci_hcd *xhci,
+                unsigned int slot_id, unsigned int ep_index,
+                struct xhci_dequeue_state *deq_state);
 
 /* xHCI roothub code */
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex,
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 4541dfcea88f..459a7287fe01 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -653,33 +653,6 @@ static struct scsi_host_template mts_scsi_host_template = {
         .max_sectors=           256, /* 128 K */
 };
 
-struct vendor_product
-{
-        char* name;
-        enum
-        {
-                mts_sup_unknown=0,
-                mts_sup_alpha,
-                mts_sup_full
-        }
-        support_status;
-} ;
-
-
-/* These are taken from the msmUSB.inf file on the Windows driver CD */
-static const struct vendor_product mts_supported_products[] =
-{
-        { "Phantom 336CX",      mts_sup_unknown},
-        { "Phantom 336CX",      mts_sup_unknown},
-        { "Scanmaker X6",       mts_sup_alpha},
-        { "Phantom C6",         mts_sup_unknown},
-        { "Phantom 336CX",      mts_sup_unknown},
-        { "ScanMaker V6USL",    mts_sup_unknown},
-        { "ScanMaker V6USL",    mts_sup_unknown},
-        { "Scanmaker V6UL",     mts_sup_unknown},
-        { "Scanmaker V6UPL",    mts_sup_alpha},
-};
-
 /* The entries of microtek_table must correspond, line-by-line to
    the entries of mts_supported_products[]. */
 
@@ -711,7 +684,6 @@ static int mts_usb_probe(struct usb_interface *intf,
         int err_retval = -ENOMEM;
 
         struct mts_desc * new_desc;
-        struct vendor_product const* p;
         struct usb_device *dev = interface_to_usbdev (intf);
 
         /* the current altsetting on the interface we're probing */
@@ -726,15 +698,6 @@ static int mts_usb_probe(struct usb_interface *intf,
 
         MTS_DEBUG_GOT_HERE();
 
-        p = &mts_supported_products[id - mts_usb_ids];
-
-        MTS_DEBUG_GOT_HERE();
-
-        MTS_DEBUG( "found model %s\n", p->name );
-        if ( p->support_status != mts_sup_full )
-                MTS_MESSAGE( "model %s is not known to be fully supported, reports welcome!\n",
-                             p->name );
-
         /* the current altsetting on the interface we're probing */
         altsetting = intf->cur_altsetting;
 
diff --git a/drivers/usb/misc/idmouse.c b/drivers/usb/misc/idmouse.c
index 6da8887538c7..1337a9ce80b9 100644
--- a/drivers/usb/misc/idmouse.c
+++ b/drivers/usb/misc/idmouse.c
@@ -96,6 +96,8 @@ static int idmouse_probe(struct usb_interface *interface,
                                 const struct usb_device_id *id);
 
 static void idmouse_disconnect(struct usb_interface *interface);
+static int idmouse_suspend(struct usb_interface *intf, pm_message_t message);
+static int idmouse_resume(struct usb_interface *intf);
 
 /* file operation pointers */
 static const struct file_operations idmouse_fops = {
@@ -117,7 +119,11 @@ static struct usb_driver idmouse_driver = {
         .name = DRIVER_SHORT,
         .probe = idmouse_probe,
         .disconnect = idmouse_disconnect,
+        .suspend = idmouse_suspend,
+        .resume = idmouse_resume,
+        .reset_resume = idmouse_resume,
         .id_table = idmouse_table,
+        .supports_autosuspend = 1,
 };
 
 static int idmouse_create_image(struct usb_idmouse *dev)
@@ -197,6 +203,17 @@ reset:
         return result;
 }
 
+/* PM operations are nops as this driver does IO only during open() */
+static int idmouse_suspend(struct usb_interface *intf, pm_message_t message)
+{
+        return 0;
+}
+
+static int idmouse_resume(struct usb_interface *intf)
+{
+        return 0;
+}
+
 static inline void idmouse_delete(struct usb_idmouse *dev)
 {
         kfree(dev->bulk_in_buffer);
@@ -235,9 +252,13 @@ static int idmouse_open(struct inode *inode, struct file *file)
         } else {
 
                 /* create a new image and check for success */
+                result = usb_autopm_get_interface(interface);
+                if (result)
+                        goto error;
                 result = idmouse_create_image (dev);
                 if (result)
                         goto error;
+                usb_autopm_put_interface(interface);
 
                 /* increment our usage count for the driver */
                 ++dev->open;
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index ad4fb15b5dcb..90f130126c10 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -412,6 +412,9 @@ static unsigned int ld_usb_poll(struct file *file, poll_table *wait)
 
         dev = file->private_data;
 
+        if (!dev->intf)
+                return POLLERR | POLLHUP;
+
         poll_wait(file, &dev->read_wait, wait);
         poll_wait(file, &dev->write_wait, wait);
 
@@ -767,6 +770,9 @@ static void ld_usb_disconnect(struct usb_interface *intf)
                 ld_usb_delete(dev);
         } else {
                 dev->intf = NULL;
+                /* wake up pollers */
+                wake_up_interruptible_all(&dev->read_wait);
+                wake_up_interruptible_all(&dev->write_wait);
                 mutex_unlock(&dev->mutex);
         }
 
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index 97efeaec4d52..faa6d623de78 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -552,6 +552,9 @@ static unsigned int tower_poll (struct file *file, poll_table *wait)
 
         dev = file->private_data;
 
+        if (!dev->udev)
+                return POLLERR | POLLHUP;
+
         poll_wait(file, &dev->read_wait, wait);
         poll_wait(file, &dev->write_wait, wait);
 
@@ -1025,6 +1028,9 @@ static void tower_disconnect (struct usb_interface *interface)
                 tower_delete (dev);
         } else {
                 dev->udev = NULL;
+                /* wake up pollers */
+                wake_up_interruptible_all(&dev->read_wait);
+                wake_up_interruptible_all(&dev->write_wait);
                 mutex_unlock(&dev->lock);
         }
 
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index b4ec716de7da..0025847743f3 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -79,14 +79,12 @@ sisusb_free_buffers(struct sisusb_usb_data *sisusb)
 
         for (i = 0; i < NUMOBUFS; i++) {
                 if (sisusb->obuf[i]) {
-                        usb_buffer_free(sisusb->sisusb_dev, sisusb->obufsize,
-                                sisusb->obuf[i], sisusb->transfer_dma_out[i]);
+                        kfree(sisusb->obuf[i]);
                         sisusb->obuf[i] = NULL;
                 }
         }
         if (sisusb->ibuf) {
-                usb_buffer_free(sisusb->sisusb_dev, sisusb->ibufsize,
-                        sisusb->ibuf, sisusb->transfer_dma_in);
+                kfree(sisusb->ibuf);
                 sisusb->ibuf = NULL;
         }
 }
@@ -230,8 +228,7 @@ sisusb_bulk_completeout(struct urb *urb)
 
 static int
 sisusb_bulkout_msg(struct sisusb_usb_data *sisusb, int index, unsigned int pipe, void *data,
-                int len, int *actual_length, int timeout, unsigned int tflags,
-                dma_addr_t transfer_dma)
+                int len, int *actual_length, int timeout, unsigned int tflags)
 {
         struct urb *urb = sisusb->sisurbout[index];
         int retval, byteswritten = 0;
@@ -245,9 +242,6 @@ sisusb_bulkout_msg(struct sisusb_usb_data *sisusb, int index, unsigned int pipe,
         urb->transfer_flags |= tflags;
         urb->actual_length = 0;
 
-        if ((urb->transfer_dma = transfer_dma))
-                urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-
         /* Set up context */
         sisusb->urbout_context[index].actual_length = (timeout) ?
                                                 NULL : actual_length;
@@ -297,8 +291,8 @@ sisusb_bulk_completein(struct urb *urb)
 }
 
 static int
-sisusb_bulkin_msg(struct sisusb_usb_data *sisusb, unsigned int pipe, void *data, int len,
-                int *actual_length, int timeout, unsigned int tflags, dma_addr_t transfer_dma)
+sisusb_bulkin_msg(struct sisusb_usb_data *sisusb, unsigned int pipe, void *data,
+        int len, int *actual_length, int timeout, unsigned int tflags)
 {
         struct urb *urb = sisusb->sisurbin;
         int retval, readbytes = 0;
@@ -311,9 +305,6 @@ sisusb_bulkin_msg(struct sisusb_usb_data *sisusb, unsigned int pipe, void *data,
         urb->transfer_flags |= tflags;
         urb->actual_length = 0;
 
-        if ((urb->transfer_dma = transfer_dma))
-                urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-
         sisusb->completein = 0;
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval == 0) {
@@ -422,8 +413,7 @@ static int sisusb_send_bulk_msg(struct sisusb_usb_data *sisusb, int ep, int len,
                                                 thispass,
                                                 &transferred_len,
                                                 async ? 0 : 5 * HZ,
-                                                tflags,
-                                                sisusb->transfer_dma_out[index]);
+                                                tflags);
 
                         if (result == -ETIMEDOUT) {
 
@@ -432,29 +422,16 @@ static int sisusb_send_bulk_msg(struct sisusb_usb_data *sisusb, int ep, int len,
                                         return -ETIME;
 
                                 continue;
+                        }
 
-                        } else if ((result == 0) && !async && transferred_len) {
+                        if ((result == 0) && !async && transferred_len) {
 
                                 thispass -= transferred_len;
-                                if (thispass) {
-                                        if (sisusb->transfer_dma_out) {
-                                                /* If DMA, copy remaining
-                                                 * to beginning of buffer
-                                                 */
-                                                memcpy(buffer,
-                                                       buffer + transferred_len,
-                                                       thispass);
-                                        } else {
-                                                /* If not DMA, simply increase
-                                                 * the pointer
-                                                 */
-                                                buffer += transferred_len;
-                                        }
-                                }
+                                buffer += transferred_len;
 
                         } else
                                 break;
-                };
+                }
 
                 if (result)
                         return result;
@@ -530,8 +507,7 @@ static int sisusb_recv_bulk_msg(struct sisusb_usb_data *sisusb, int ep, int len,
                                            thispass,
                                            &transferred_len,
                                            5 * HZ,
-                                           tflags,
-                                           sisusb->transfer_dma_in);
+                                           tflags);
 
                 if (transferred_len)
                         thispass = transferred_len;
@@ -3132,8 +3108,7 @@ static int sisusb_probe(struct usb_interface *intf,
 
         /* Allocate buffers */
         sisusb->ibufsize = SISUSB_IBUF_SIZE;
-        if (!(sisusb->ibuf = usb_buffer_alloc(dev, SISUSB_IBUF_SIZE,
-                                        GFP_KERNEL, &sisusb->transfer_dma_in))) {
+        if (!(sisusb->ibuf = kmalloc(SISUSB_IBUF_SIZE, GFP_KERNEL))) {
                 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate memory for input buffer");
                 retval = -ENOMEM;
                 goto error_2;
@@ -3142,9 +3117,7 @@ static int sisusb_probe(struct usb_interface *intf,
         sisusb->numobufs = 0;
         sisusb->obufsize = SISUSB_OBUF_SIZE;
         for (i = 0; i < NUMOBUFS; i++) {
-                if (!(sisusb->obuf[i] = usb_buffer_alloc(dev, SISUSB_OBUF_SIZE,
-                                        GFP_KERNEL,
-                                        &sisusb->transfer_dma_out[i]))) {
+                if (!(sisusb->obuf[i] = kmalloc(SISUSB_OBUF_SIZE, GFP_KERNEL))) {
                         if (i == 0) {
                                 dev_err(&sisusb->sisusb_dev->dev, "Failed to allocate memory for output buffer\n");
                                 retval = -ENOMEM;
diff --git a/drivers/usb/misc/sisusbvga/sisusb.h b/drivers/usb/misc/sisusbvga/sisusb.h
index cf0b4a5883f6..55492a5930bd 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.h
+++ b/drivers/usb/misc/sisusbvga/sisusb.h
@@ -123,8 +123,6 @@ struct sisusb_usb_data {
         int numobufs;           /* number of obufs = number of out urbs */
         char *obuf[NUMOBUFS], *ibuf;    /* transfer buffers */
         int obufsize, ibufsize;
-        dma_addr_t transfer_dma_out[NUMOBUFS];
-        dma_addr_t transfer_dma_in;
         struct urb *sisurbout[NUMOBUFS];
         struct urb *sisurbin;
         unsigned char urbstatus[NUMOBUFS];
diff --git a/drivers/usb/misc/usbsevseg.c b/drivers/usb/misc/usbsevseg.c
index 28a6a3a09538..3db255537e79 100644
--- a/drivers/usb/misc/usbsevseg.c
+++ b/drivers/usb/misc/usbsevseg.c
@@ -38,6 +38,7 @@ static char *display_textmodes[] = {"raw", "hex", "ascii", NULL};
 
 struct usb_sevsegdev {
         struct usb_device *udev;
+        struct usb_interface *intf;
 
         u8 powered;
         u8 mode_msb;
@@ -46,6 +47,8 @@ struct usb_sevsegdev {
         u8 textmode;
         u8 text[MAXLEN];
         u16 textlength;
+
+        u8 shadow_power; /* for PM */
 };
 
 /* sysfs_streq can't replace this completely
@@ -65,6 +68,12 @@ static void update_display_powered(struct usb_sevsegdev *mydev)
 {
         int rc;
 
+        if (!mydev->shadow_power && mydev->powered) {
+                rc = usb_autopm_get_interface(mydev->intf);
+                if (rc < 0)
+                        return;
+        }
+
         rc = usb_control_msg(mydev->udev,
                         usb_sndctrlpipe(mydev->udev, 0),
                         0x12,
@@ -76,12 +85,18 @@ static void update_display_powered(struct usb_sevsegdev *mydev)
                         2000);
         if (rc < 0)
                 dev_dbg(&mydev->udev->dev, "power retval = %d\n", rc);
+
+        if (mydev->shadow_power && !mydev->powered)
+                usb_autopm_put_interface(mydev->intf);
 }
 
 static void update_display_mode(struct usb_sevsegdev *mydev)
 {
         int rc;
 
+        if(mydev->shadow_power != 1)
+                return;
+
         rc = usb_control_msg(mydev->udev,
                         usb_sndctrlpipe(mydev->udev, 0),
                         0x12,
@@ -96,14 +111,17 @@ static void update_display_mode(struct usb_sevsegdev *mydev)
                 dev_dbg(&mydev->udev->dev, "mode retval = %d\n", rc);
 }
 
-static void update_display_visual(struct usb_sevsegdev *mydev)
+static void update_display_visual(struct usb_sevsegdev *mydev, gfp_t mf)
 {
         int rc;
         int i;
         unsigned char *buffer;
         u8 decimals = 0;
 
-        buffer = kzalloc(MAXLEN, GFP_KERNEL);
+        if(mydev->shadow_power != 1)
+                return;
+
+        buffer = kzalloc(MAXLEN, mf);
         if (!buffer) {
                 dev_err(&mydev->udev->dev, "out of memory\n");
                 return;
@@ -163,7 +181,7 @@ static ssize_t set_attr_##name(struct device *dev, 		\
         struct usb_sevsegdev *mydev = usb_get_intfdata(intf);   \
                                                                 \
         mydev->name = simple_strtoul(buf, NULL, 10);            \
-        update_fcn(mydev); \
+        update_fcn(mydev);                                      \
                                                                 \
         return count;                                           \
 }                                                               \
@@ -194,7 +212,7 @@ static ssize_t set_attr_text(struct device *dev,
         if (end > 0)
                 memcpy(mydev->text, buf, end);
 
-        update_display_visual(mydev);
+        update_display_visual(mydev, GFP_KERNEL);
         return count;
 }
 
@@ -242,7 +260,7 @@ static ssize_t set_attr_decimals(struct device *dev,
                 if (buf[i] == '1')
                         mydev->decimals[end-1-i] = 1;
 
-        update_display_visual(mydev);
+        update_display_visual(mydev, GFP_KERNEL);
 
         return count;
 }
@@ -286,7 +304,7 @@ static ssize_t set_attr_textmode(struct device *dev,
         for (i = 0; display_textmodes[i]; i++) {
                 if (sysfs_streq(display_textmodes[i], buf)) {
                         mydev->textmode = i;
-                        update_display_visual(mydev);
+                        update_display_visual(mydev, GFP_KERNEL);
                         return count;
                 }
         }
@@ -330,6 +348,7 @@ static int sevseg_probe(struct usb_interface *interface,
         }
 
         mydev->udev = usb_get_dev(udev);
+        mydev->intf = interface;
         usb_set_intfdata(interface, mydev);
 
         /*set defaults */
@@ -364,11 +383,49 @@ static void sevseg_disconnect(struct usb_interface *interface)
         dev_info(&interface->dev, "USB 7 Segment now disconnected\n");
 }
 
+static int sevseg_suspend(struct usb_interface *intf, pm_message_t message)
+{
+        struct usb_sevsegdev *mydev;
+
+        mydev = usb_get_intfdata(intf);
+        mydev->shadow_power = 0;
+
+        return 0;
+}
+
+static int sevseg_resume(struct usb_interface *intf)
+{
+        struct usb_sevsegdev *mydev;
+
+        mydev = usb_get_intfdata(intf);
+        mydev->shadow_power = 1;
+        update_display_mode(mydev);
+        update_display_visual(mydev, GFP_NOIO);
+
+        return 0;
+}
+
+static int sevseg_reset_resume(struct usb_interface *intf)
+{
+        struct usb_sevsegdev *mydev;
+
+        mydev = usb_get_intfdata(intf);
+        mydev->shadow_power = 1;
+        update_display_mode(mydev);
+        update_display_visual(mydev, GFP_NOIO);
+
+        return 0;
+}
+
 static struct usb_driver sevseg_driver = {
         .name =         "usbsevseg",
         .probe =        sevseg_probe,
         .disconnect =   sevseg_disconnect,
+        .suspend =      sevseg_suspend,
+        .resume =       sevseg_resume,
+        .reset_resume = sevseg_reset_resume,
         .id_table =     id_table,
+        .supports_autosuspend = 1,
 };
 
 static int __init usb_sevseg_init(void)
diff --git a/drivers/usb/mon/Kconfig b/drivers/usb/mon/Kconfig
index f28f350cd96a..635745f57fbd 100644
--- a/drivers/usb/mon/Kconfig
+++ b/drivers/usb/mon/Kconfig
@@ -5,11 +5,9 @@
 config USB_MON
         tristate "USB Monitor"
         depends on USB
-        default y if USB=y
-        default m if USB=m
         help
           If you select this option, a component which captures the USB traffic
           between peripheral-specific drivers and HC drivers will be built.
           For more information, see <file:Documentation/usb/usbmon.txt>.
 
-          If unsure, say Y (if allowed), otherwise M.
+          If unsure, say Y, if allowed, otherwise M.
diff --git a/drivers/usb/mon/Makefile b/drivers/usb/mon/Makefile
index c6516b566731..384b198faa7c 100644
--- a/drivers/usb/mon/Makefile
+++ b/drivers/usb/mon/Makefile
@@ -2,6 +2,6 @@
 # Makefile for USB monitor
 #
 
-usbmon-objs     := mon_main.o mon_stat.o mon_text.o mon_bin.o mon_dma.o
+usbmon-objs     := mon_main.o mon_stat.o mon_text.o mon_bin.o
 
 obj-$(CONFIG_USB_MON)   += usbmon.o
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index 0f7a30b7d2d1..dfdc43e2e00d 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -220,9 +220,8 @@ static void mon_free_buff(struct mon_pgmap *map, int npages);
 
 /*
  * This is a "chunked memcpy". It does not manipulate any counters.
- * But it returns the new offset for repeated application.
  */
-unsigned int mon_copy_to_buff(const struct mon_reader_bin *this,
+static void mon_copy_to_buff(const struct mon_reader_bin *this,
     unsigned int off, const unsigned char *from, unsigned int length)
 {
         unsigned int step_len;
@@ -247,7 +246,6 @@ unsigned int mon_copy_to_buff(const struct mon_reader_bin *this,
                 from += step_len;
                 length -= step_len;
         }
-        return off;
 }
 
 /*
@@ -400,15 +398,8 @@ static char mon_bin_get_data(const struct mon_reader_bin *rp,
     unsigned int offset, struct urb *urb, unsigned int length)
 {
 
-        if (urb->dev->bus->uses_dma &&
-            (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
-                mon_dmapeek_vec(rp, offset, urb->transfer_dma, length);
-                return 0;
-        }
-
         if (urb->transfer_buffer == NULL)
                 return 'Z';
-
         mon_copy_to_buff(rp, offset, urb->transfer_buffer, length);
         return 0;
 }
@@ -635,7 +626,6 @@ static int mon_bin_open(struct inode *inode, struct file *file)
         spin_lock_init(&rp->b_lock);
         init_waitqueue_head(&rp->b_wait);
         mutex_init(&rp->fetch_lock);
-
         rp->b_size = BUFF_DFL;
 
         size = sizeof(struct mon_pgmap) * (rp->b_size/CHUNK_SIZE);
diff --git a/drivers/usb/mon/mon_dma.c b/drivers/usb/mon/mon_dma.c
deleted file mode 100644
index 140cc80bd2b1..000000000000
--- a/drivers/usb/mon/mon_dma.c
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * The USB Monitor, inspired by Dave Harding's USBMon.
- *
- * mon_dma.c: Library which snoops on DMA areas.
- *
- * Copyright (C) 2005 Pete Zaitcev (zaitcev@redhat.com)
- */
-#include <linux/kernel.h>
-#include <linux/list.h>
-#include <linux/highmem.h>
-#include <asm/page.h>
-
-#include <linux/usb.h>  /* Only needed for declarations in usb_mon.h */
-#include "usb_mon.h"
-
-/*
- * PC-compatibles, are, fortunately, sufficiently cache-coherent for this.
- */
-#if defined(__i386__) || defined(__x86_64__) /* CONFIG_ARCH_I386 doesn't exit */
-#define MON_HAS_UNMAP 1
-
-#define phys_to_page(phys)      pfn_to_page((phys) >> PAGE_SHIFT)
-
-char mon_dmapeek(unsigned char *dst, dma_addr_t dma_addr, int len)
-{
-        struct page *pg;
-        unsigned long flags;
-        unsigned char *map;
-        unsigned char *ptr;
-
-        /*
-         * On i386, a DMA handle is the "physical" address of a page.
-         * In other words, the bus address is equal to physical address.
-         * There is no IOMMU.
-         */
-        pg = phys_to_page(dma_addr);
-
-        /*
-         * We are called from hardware IRQs in case of callbacks.
-         * But we can be called from softirq or process context in case
-         * of submissions. In such case, we need to protect KM_IRQ0.
-         */
-        local_irq_save(flags);
-        map = kmap_atomic(pg, KM_IRQ0);
-        ptr = map + (dma_addr & (PAGE_SIZE-1));
-        memcpy(dst, ptr, len);
-        kunmap_atomic(map, KM_IRQ0);
-        local_irq_restore(flags);
-        return 0;
-}
-
-void mon_dmapeek_vec(const struct mon_reader_bin *rp,
-    unsigned int offset, dma_addr_t dma_addr, unsigned int length)
-{
-        unsigned long flags;
-        unsigned int step_len;
-        struct page *pg;
-        unsigned char *map;
-        unsigned long page_off, page_len;
-
-        local_irq_save(flags);
-        while (length) {
-                /* compute number of bytes we are going to copy in this page */
-                step_len = length;
-                page_off = dma_addr & (PAGE_SIZE-1);
-                page_len = PAGE_SIZE - page_off;
-                if (page_len < step_len)
-                        step_len = page_len;
-
-                /* copy data and advance pointers */
-                pg = phys_to_page(dma_addr);
-                map = kmap_atomic(pg, KM_IRQ0);
-                offset = mon_copy_to_buff(rp, offset, map + page_off, step_len);
-                kunmap_atomic(map, KM_IRQ0);
-                dma_addr += step_len;
-                length -= step_len;
-        }
-        local_irq_restore(flags);
-}
-
-#endif /* __i386__ */
-
-#ifndef MON_HAS_UNMAP
-char mon_dmapeek(unsigned char *dst, dma_addr_t dma_addr, int len)
-{
-        return 'D';
-}
-
-void mon_dmapeek_vec(const struct mon_reader_bin *rp,
-    unsigned int offset, dma_addr_t dma_addr, unsigned int length)
-{
-        ;
-}
-
-#endif /* MON_HAS_UNMAP */
diff --git a/drivers/usb/mon/mon_main.c b/drivers/usb/mon/mon_main.c
index 5e0ab4201c00..e0c2db3b767b 100644
--- a/drivers/usb/mon/mon_main.c
+++ b/drivers/usb/mon/mon_main.c
@@ -361,7 +361,6 @@ static int __init mon_init(void)
         }
         // MOD_INC_USE_COUNT(which_module?);
 
-
         mutex_lock(&usb_bus_list_lock);
         list_for_each_entry (ubus, &usb_bus_list, bus_list) {
                 mon_bus_init(ubus);
diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c
index a7eb4c99342c..9f1a9227ebe6 100644
--- a/drivers/usb/mon/mon_text.c
+++ b/drivers/usb/mon/mon_text.c
@@ -150,20 +150,6 @@ static inline char mon_text_get_data(struct mon_event_text *ep, struct urb *urb,
                         return '>';
         }
 
-        /*
-         * The check to see if it's safe to poke at data has an enormous
-         * number of corner cases, but it seems that the following is
-         * more or less safe.
-         *
-         * We do not even try to look at transfer_buffer, because it can
-         * contain non-NULL garbage in case the upper level promised to
-         * set DMA for the HCD.
-         */
-        if (urb->dev->bus->uses_dma &&
-            (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
-                return mon_dmapeek(ep->data, urb->transfer_dma, len);
-        }
-
         if (urb->transfer_buffer == NULL)
                 return 'Z';     /* '0' would be not as pretty. */
 
diff --git a/drivers/usb/mon/usb_mon.h b/drivers/usb/mon/usb_mon.h
index f5d84ff8c101..df9a4df342c7 100644
--- a/drivers/usb/mon/usb_mon.h
+++ b/drivers/usb/mon/usb_mon.h
@@ -65,20 +65,6 @@ int __init mon_bin_init(void);
 void mon_bin_exit(void);
 
 /*
- * DMA interface.
- *
- * XXX The vectored side needs a serious re-thinking. Abstracting vectors,
- * like in Paolo's original patch, produces a double pkmap. We need an idea.
-*/
-extern char mon_dmapeek(unsigned char *dst, dma_addr_t dma_addr, int len);
-
-struct mon_reader_bin;
-extern void mon_dmapeek_vec(const struct mon_reader_bin *rp,
-    unsigned int offset, dma_addr_t dma_addr, unsigned int len);
-extern unsigned int mon_copy_to_buff(const struct mon_reader_bin *rp,
-    unsigned int offset, const unsigned char *from, unsigned int len);
-
-/*
  */
 extern struct mutex mon_lock;
 
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 1d26beddf2ca..3a61ddb62bd2 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -1850,6 +1850,10 @@ static void musb_free(struct musb *musb)
                 dma_controller_destroy(c);
         }
 
+#ifdef CONFIG_USB_MUSB_OTG
+        put_device(musb->xceiv->dev);
+#endif
+
         musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
         musb_platform_exit(musb);
         musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
@@ -1859,10 +1863,6 @@ static void musb_free(struct musb *musb)
                 clk_put(musb->clock);
         }
 
-#ifdef CONFIG_USB_MUSB_OTG
-        put_device(musb->xceiv->dev);
-#endif
-
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
         usb_put_hcd(musb_to_hcd(musb));
 #else
diff --git a/drivers/usb/otg/isp1301_omap.c b/drivers/usb/otg/isp1301_omap.c
index e0d56ef2bcb0..77a5f4188999 100644
--- a/drivers/usb/otg/isp1301_omap.c
+++ b/drivers/usb/otg/isp1301_omap.c
@@ -117,24 +117,7 @@ static void enable_vbus_draw(struct isp1301 *isp, unsigned mA)
                 pr_debug("  VBUS %d mA error %d\n", mA, status);
 }
 
-static void enable_vbus_source(struct isp1301 *isp)
-{
-        /* this board won't supply more than 8mA vbus power.
-         * some boards can switch a 100ma "unit load" (or more).
-         */
-}
-
-
-/* products will deliver OTG messages with LEDs, GUI, etc */
-static inline void notresponding(struct isp1301 *isp)
-{
-        printk(KERN_NOTICE "OTG device not responding.\n");
-}
-
-
-#endif
-
-#if defined(CONFIG_MACH_OMAP_H4)
+#else
 
 static void enable_vbus_draw(struct isp1301 *isp, unsigned mA)
 {
@@ -144,6 +127,8 @@ static void enable_vbus_draw(struct isp1301 *isp, unsigned mA)
          */
 }
 
+#endif
+
 static void enable_vbus_source(struct isp1301 *isp)
 {
         /* this board won't supply more than 8mA vbus power.
@@ -159,8 +144,6 @@ static inline void notresponding(struct isp1301 *isp)
 }
 
 
-#endif
-
 /*-------------------------------------------------------------------------*/
 
 static struct i2c_driver isp1301_driver;
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index 5d25d3e52bf6..131e61adaaf7 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -31,10 +31,20 @@ static int debug;
 
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x6547, 0x0232) },
+        { USB_DEVICE(0x18ec, 0x3118) },         /* USB to IrDA adapter */
         { },
 };
 MODULE_DEVICE_TABLE(usb, id_table);
 
+static int is_irda(struct usb_serial *serial)
+{
+        struct usb_device *dev = serial->dev;
+        if (le16_to_cpu(dev->descriptor.idVendor) == 0x18ec &&
+                        le16_to_cpu(dev->descriptor.idProduct) == 0x3118)
+                return 1;
+        return 0;
+}
+
 static inline void ARK3116_SND(struct usb_serial *serial, int seq,
                                __u8 request, __u8 requesttype,
                                __u16 value, __u16 index)
@@ -84,11 +94,21 @@ static int ark3116_attach(struct usb_serial *serial)
                 return -ENOMEM;
         }
 
+        if (is_irda(serial))
+                dbg("IrDA mode");
+
         /* 3 */
         ARK3116_SND(serial, 3, 0xFE, 0x40, 0x0008, 0x0002);
         ARK3116_SND(serial, 4, 0xFE, 0x40, 0x0008, 0x0001);
         ARK3116_SND(serial, 5, 0xFE, 0x40, 0x0000, 0x0008);
-        ARK3116_SND(serial, 6, 0xFE, 0x40, 0x0000, 0x000B);
+        ARK3116_SND(serial, 6, 0xFE, 0x40, is_irda(serial) ? 0x0001 : 0x0000,
+                    0x000B);
+
+        if (is_irda(serial)) {
+                ARK3116_SND(serial, 1001, 0xFE, 0x40, 0x0000, 0x000C);
+                ARK3116_SND(serial, 1002, 0xFE, 0x40, 0x0041, 0x000D);
+                ARK3116_SND(serial, 1003, 0xFE, 0x40, 0x0001, 0x000A);
+        }
 
         /* <-- seq7 */
         ARK3116_RCV(serial,  7, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
@@ -125,6 +145,8 @@ static int ark3116_attach(struct usb_serial *serial)
         ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
         ARK3116_SND(serial, 148, 0xFE, 0x40, 0x0038, 0x0000);
         ARK3116_SND(serial, 149, 0xFE, 0x40, 0x0001, 0x0001);
+        if (is_irda(serial))
+                ARK3116_SND(serial, 1004, 0xFE, 0x40, 0x0000, 0x0009);
         ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
         ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
         ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index 8c894a7d5dcf..59eff721fcc5 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -56,6 +56,18 @@
 #define CH341_BAUDBASE_FACTOR 1532620800
 #define CH341_BAUDBASE_DIVMAX 3
 
+/* Break support - the information used to implement this was gleaned from
+ * the Net/FreeBSD uchcom.c driver by Takanori Watanabe.  Domo arigato.
+ */
+
+#define CH341_REQ_WRITE_REG    0x9A
+#define CH341_REQ_READ_REG     0x95
+#define CH341_REG_BREAK1       0x05
+#define CH341_REG_BREAK2       0x18
+#define CH341_NBREAK_BITS_REG1 0x01
+#define CH341_NBREAK_BITS_REG2 0x40
+
+
 static int debug;
 
 static struct usb_device_id id_table [] = {
@@ -373,6 +385,45 @@ static void ch341_set_termios(struct tty_struct *tty,
          */
 }
 
+static void ch341_break_ctl(struct tty_struct *tty, int break_state)
+{
+        const uint16_t ch341_break_reg =
+                CH341_REG_BREAK1 | ((uint16_t) CH341_REG_BREAK2 << 8);
+        struct usb_serial_port *port = tty->driver_data;
+        int r;
+        uint16_t reg_contents;
+        uint8_t break_reg[2];
+
+        dbg("%s()", __func__);
+
+        r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
+                        ch341_break_reg, 0, break_reg, sizeof(break_reg));
+        if (r < 0) {
+                printk(KERN_WARNING "%s: USB control read error whilst getting"
+                                " break register contents.\n", __FILE__);
+                return;
+        }
+        dbg("%s - initial ch341 break register contents - reg1: %x, reg2: %x",
+                        __func__, break_reg[0], break_reg[1]);
+        if (break_state != 0) {
+                dbg("%s - Enter break state requested", __func__);
+                break_reg[0] &= ~CH341_NBREAK_BITS_REG1;
+                break_reg[1] &= ~CH341_NBREAK_BITS_REG2;
+        } else {
+                dbg("%s - Leave break state requested", __func__);
+                break_reg[0] |= CH341_NBREAK_BITS_REG1;
+                break_reg[1] |= CH341_NBREAK_BITS_REG2;
+        }
+        dbg("%s - New ch341 break register contents - reg1: %x, reg2: %x",
+                        __func__, break_reg[0], break_reg[1]);
+        reg_contents = (uint16_t)break_reg[0] | ((uint16_t)break_reg[1] << 8);
+        r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
+                        ch341_break_reg, reg_contents);
+        if (r < 0)
+                printk(KERN_WARNING "%s: USB control write error whilst setting"
+                                " break register contents.\n", __FILE__);
+}
+
 static int ch341_tiocmset(struct tty_struct *tty, struct file *file,
                           unsigned int set, unsigned int clear)
 {
@@ -576,6 +627,7 @@ static struct usb_serial_driver ch341_device = {
         .close             = ch341_close,
         .ioctl             = ch341_ioctl,
         .set_termios       = ch341_set_termios,
+        .break_ctl         = ch341_break_ctl,
         .tiocmget          = ch341_tiocmget,
         .tiocmset          = ch341_tiocmset,
         .read_int_callback = ch341_read_int_callback,
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 76a17f915eef..4f883b1773d0 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -176,6 +176,9 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
@@ -694,6 +697,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(DE_VID, WHT_PID) },
         { USB_DEVICE(ADI_VID, ADI_GNICE_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+        { USB_DEVICE(ADI_VID, ADI_GNICEPLUS_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(JETI_VID, JETI_SPC1201_PID) },
         { USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
@@ -702,6 +707,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(BAYER_VID, BAYER_CONTOUR_CABLE_PID) },
         { USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+        { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
+        { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index 8c92b88166ae..6f31e0d71898 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -81,6 +81,9 @@
 
 /* OpenDCC (www.opendcc.de) product id */
 #define FTDI_OPENDCC_PID        0xBFD8
+#define FTDI_OPENDCC_SNIFFER_PID        0xBFD9
+#define FTDI_OPENDCC_THROTTLE_PID       0xBFDA
+#define FTDI_OPENDCC_GATEWAY_PID        0xBFDB
 
 /* Sprog II (Andrew Crosland's SprogII DCC interface) */
 #define FTDI_SPROG_II           0xF0C8
@@ -930,6 +933,7 @@
  */
 #define ADI_VID                 0x0456
 #define ADI_GNICE_PID           0xF000
+#define ADI_GNICEPLUS_PID       0xF001
 
 /*
  * JETI SPECTROMETER SPECBOS 1201
@@ -968,6 +972,12 @@
 #define MARVELL_OPENRD_PID      0x9e90
 
 /*
+ * Hameg HO820 and HO870 interface (using VID 0x0403)
+ */
+#define        HAMEG_HO820_PID         0xed74
+#define        HAMEG_HO870_PID         0xed71
+
+/*
  *   BmRequestType:  1100 0000b
  *   bRequest:       FTDI_E2_READ
  *   wValue:         0
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index d9398e9f30ce..deba08c7a015 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -19,7 +19,7 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include <linux/uaccess.h>
-
+#include <linux/kfifo.h>
 
 static int debug;
 
@@ -166,24 +166,6 @@ static void generic_cleanup(struct usb_serial_port *port)
         }
 }
 
-int usb_serial_generic_resume(struct usb_serial *serial)
-{
-        struct usb_serial_port *port;
-        int i, c = 0, r;
-
-        for (i = 0; i < serial->num_ports; i++) {
-                port = serial->port[i];
-                if (port->port.count && port->read_urb) {
-                        r = usb_submit_urb(port->read_urb, GFP_NOIO);
-                        if (r < 0)
-                                c++;
-                }
-        }
-
-        return c ? -EIO : 0;
-}
-EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
-
 void usb_serial_generic_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
@@ -272,12 +254,81 @@ error_no_buffer:
         return bwrite;
 }
 
+/**
+ * usb_serial_generic_write_start - kick off an URB write
+ * @port:       Pointer to the &struct usb_serial_port data
+ *
+ * Returns the number of bytes queued on success. This will be zero if there
+ * was nothing to send. Otherwise, it returns a negative errno value
+ */
+static int usb_serial_generic_write_start(struct usb_serial_port *port)
+{
+        struct usb_serial *serial = port->serial;
+        unsigned char *data;
+        int result;
+        int count;
+        unsigned long flags;
+        bool start_io;
+
+        /* Atomically determine whether we can and need to start a USB
+         * operation. */
+        spin_lock_irqsave(&port->lock, flags);
+        if (port->write_urb_busy)
+                start_io = false;
+        else {
+                start_io = (__kfifo_len(port->write_fifo) != 0);
+                port->write_urb_busy = start_io;
+        }
+        spin_unlock_irqrestore(&port->lock, flags);
+
+        if (!start_io)
+                return 0;
+
+        data = port->write_urb->transfer_buffer;
+        count = kfifo_get(port->write_fifo, data, port->bulk_out_size);
+        usb_serial_debug_data(debug, &port->dev, __func__, count, data);
+
+        /* set up our urb */
+        usb_fill_bulk_urb(port->write_urb, serial->dev,
+                           usb_sndbulkpipe(serial->dev,
+                                port->bulk_out_endpointAddress),
+                           port->write_urb->transfer_buffer, count,
+                           ((serial->type->write_bulk_callback) ?
+                             serial->type->write_bulk_callback :
+                             usb_serial_generic_write_bulk_callback),
+                           port);
+
+        /* send the data out the bulk port */
+        result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
+        if (result) {
+                dev_err(&port->dev,
+                        "%s - failed submitting write urb, error %d\n",
+                                                __func__, result);
+                /* don't have to grab the lock here, as we will
+                   retry if != 0 */
+                port->write_urb_busy = 0;
+        } else
+                result = count;
+
+        return result;
+}
+
+/**
+ * usb_serial_generic_write - generic write function for serial USB devices
+ * @tty:        Pointer to &struct tty_struct for the device
+ * @port:       Pointer to the &usb_serial_port structure for the device
+ * @buf:        Pointer to the data to write
+ * @count:      Number of bytes to write
+ *
+ * Returns the number of characters actually written, which may be anything
+ * from zero to @count. If an error occurs, it returns the negative errno
+ * value.
+ */
 int usb_serial_generic_write(struct tty_struct *tty,
         struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         struct usb_serial *serial = port->serial;
         int result;
-        unsigned char *data;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -287,57 +338,20 @@ int usb_serial_generic_write(struct tty_struct *tty,
         }
 
         /* only do something if we have a bulk out endpoint */
-        if (serial->num_bulk_out) {
-                unsigned long flags;
-
-                if (serial->type->max_in_flight_urbs)
-                        return usb_serial_multi_urb_write(tty, port,
-                                                          buf, count);
-
-                spin_lock_irqsave(&port->lock, flags);
-                if (port->write_urb_busy) {
-                        spin_unlock_irqrestore(&port->lock, flags);
-                        dbg("%s - already writing", __func__);
-                        return 0;
-                }
-                port->write_urb_busy = 1;
-                spin_unlock_irqrestore(&port->lock, flags);
-
-                count = (count > port->bulk_out_size) ?
-                                        port->bulk_out_size : count;
-
-                memcpy(port->write_urb->transfer_buffer, buf, count);
-                data = port->write_urb->transfer_buffer;
-                usb_serial_debug_data(debug, &port->dev, __func__, count, data);
+        if (!serial->num_bulk_out)
+                return 0;
 
-                /* set up our urb */
-                usb_fill_bulk_urb(port->write_urb, serial->dev,
-                                   usb_sndbulkpipe(serial->dev,
-                                        port->bulk_out_endpointAddress),
-                                   port->write_urb->transfer_buffer, count,
-                                   ((serial->type->write_bulk_callback) ?
-                                     serial->type->write_bulk_callback :
-                                     usb_serial_generic_write_bulk_callback),
-                                   port);
+        if (serial->type->max_in_flight_urbs)
+                return usb_serial_multi_urb_write(tty, port,
+                                                  buf, count);
 
-                /* send the data out the bulk port */
-                port->write_urb_busy = 1;
-                result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
-                if (result) {
-                        dev_err(&port->dev,
-                                "%s - failed submitting write urb, error %d\n",
-                                                        __func__, result);
-                        /* don't have to grab the lock here, as we will
-                           retry if != 0 */
-                        port->write_urb_busy = 0;
-                } else
-                        result = count;
+        count = kfifo_put(port->write_fifo, buf, count);
+        result = usb_serial_generic_write_start(port);
 
-                return result;
-        }
+        if (result >= 0)
+                result = count;
 
-        /* no bulk out, so return 0 bytes written */
-        return 0;
+        return result;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write);
 
@@ -355,9 +369,8 @@ int usb_serial_generic_write_room(struct tty_struct *tty)
                         room = port->bulk_out_size *
                                 (serial->type->max_in_flight_urbs -
                                  port->urbs_in_flight);
-        } else if (serial->num_bulk_out && !(port->write_urb_busy)) {
-                room = port->bulk_out_size;
-        }
+        } else if (serial->num_bulk_out)
+                room = port->write_fifo->size - __kfifo_len(port->write_fifo);
         spin_unlock_irqrestore(&port->lock, flags);
 
         dbg("%s - returns %d", __func__, room);
@@ -377,11 +390,8 @@ int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
                 spin_lock_irqsave(&port->lock, flags);
                 chars = port->tx_bytes_flight;
                 spin_unlock_irqrestore(&port->lock, flags);
-        } else if (serial->num_bulk_out) {
-                /* FIXME: Locking */
-                if (port->write_urb_busy)
-                        chars = port->write_urb->transfer_buffer_length;
-        }
+        } else if (serial->num_bulk_out)
+                chars = kfifo_len(port->write_fifo);
 
         dbg("%s - returns %d", __func__, chars);
         return chars;
@@ -485,16 +495,23 @@ void usb_serial_generic_write_bulk_callback(struct urb *urb)
                 if (port->urbs_in_flight < 0)
                         port->urbs_in_flight = 0;
                 spin_unlock_irqrestore(&port->lock, flags);
+
+                if (status) {
+                        dbg("%s - nonzero multi-urb write bulk status "
+                                "received: %d", __func__, status);
+                        return;
+                }
         } else {
-                /* Handle the case for single urb mode */
                 port->write_urb_busy = 0;
-        }
 
-        if (status) {
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
-                return;
+                if (status) {
+                        dbg("%s - nonzero multi-urb write bulk status "
+                                "received: %d", __func__, status);
+                        kfifo_reset(port->write_fifo);
+                } else
+                        usb_serial_generic_write_start(port);
         }
+
         usb_serial_port_softint(port);
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
@@ -559,6 +576,33 @@ int usb_serial_handle_break(struct usb_serial_port *port)
 }
 EXPORT_SYMBOL_GPL(usb_serial_handle_break);
 
+int usb_serial_generic_resume(struct usb_serial *serial)
+{
+        struct usb_serial_port *port;
+        int i, c = 0, r;
+
+        for (i = 0; i < serial->num_ports; i++) {
+                port = serial->port[i];
+                if (!port->port.count)
+                        continue;
+
+                if (port->read_urb) {
+                        r = usb_submit_urb(port->read_urb, GFP_NOIO);
+                        if (r < 0)
+                                c++;
+                }
+
+                if (port->write_urb) {
+                        r = usb_serial_generic_write_start(port);
+                        if (r < 0)
+                                c++;
+                }
+        }
+
+        return c ? -EIO : 0;
+}
+EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
+
 void usb_serial_generic_disconnect(struct usb_serial *serial)
 {
         int i;
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index 6138c1cda35f..e6e02b178d2b 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -40,7 +40,7 @@ static int debug;
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.10"
+#define DRIVER_VERSION "v0.11"
 #define DRIVER_DESC "Infinity USB Unlimited Phoenix driver"
 
 static struct usb_device_id id_table[] = {
@@ -64,6 +64,7 @@ static int cdmode = 1;
 static int iuu_cardin;
 static int iuu_cardout;
 static int xmas;
+static int vcc_default = 5;
 
 static void read_rxcmd_callback(struct urb *urb);
 
@@ -79,6 +80,7 @@ struct iuu_private {
         u8 *buf;                /* used for initialize speed */
         u8 *dbgbuf;             /* debug buffer */
         u8 len;
+        int vcc;                /* vcc (either 3 or 5 V) */
 };
 
 
@@ -114,6 +116,7 @@ static int iuu_startup(struct usb_serial *serial)
                 kfree(priv);
                 return -ENOMEM;
         }
+        priv->vcc = vcc_default;
         spin_lock_init(&priv->lock);
         init_waitqueue_head(&priv->delta_msr_wait);
         usb_set_serial_port_data(serial->port[0], priv);
@@ -1009,11 +1012,7 @@ static void iuu_close(struct usb_serial_port *port)
                 usb_kill_urb(port->write_urb);
                 usb_kill_urb(port->read_urb);
                 usb_kill_urb(port->interrupt_in_urb);
-                msleep(1000);
-                /* wait one second to free all buffers */
                 iuu_led(port, 0, 0, 0xF000, 0xFF);
-                msleep(1000);
-                usb_reset_device(port->serial->dev);
         }
 }
 
@@ -1182,6 +1181,95 @@ static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
         return result;
 }
 
+/* how to change VCC */
+static int iuu_vcc_set(struct usb_serial_port *port, unsigned int vcc)
+{
+        int status;
+        u8 *buf;
+
+        buf = kmalloc(5, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        dbg("%s - enter", __func__);
+
+        buf[0] = IUU_SET_VCC;
+        buf[1] = vcc & 0xFF;
+        buf[2] = (vcc >> 8) & 0xFF;
+        buf[3] = (vcc >> 16) & 0xFF;
+        buf[4] = (vcc >> 24) & 0xFF;
+
+        status = bulk_immediate(port, buf, 5);
+        kfree(buf);
+
+        if (status != IUU_OPERATION_OK)
+                dbg("%s - vcc error status = %2x", __func__, status);
+        else
+                dbg("%s - vcc OK !", __func__);
+
+        return status;
+}
+
+/*
+ * Sysfs Attributes
+ */
+
+static ssize_t show_vcc_mode(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct usb_serial_port *port = to_usb_serial_port(dev);
+        struct iuu_private *priv = usb_get_serial_port_data(port);
+
+        return sprintf(buf, "%d\n", priv->vcc);
+}
+
+static ssize_t store_vcc_mode(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct usb_serial_port *port = to_usb_serial_port(dev);
+        struct iuu_private *priv = usb_get_serial_port_data(port);
+        unsigned long v;
+
+        if (strict_strtoul(buf, 10, &v)) {
+                dev_err(dev, "%s - vcc_mode: %s is not a unsigned long\n",
+                                __func__, buf);
+                goto fail_store_vcc_mode;
+        }
+
+        dbg("%s: setting vcc_mode = %ld", __func__, v);
+
+        if ((v != 3) && (v != 5)) {
+                dev_err(dev, "%s - vcc_mode %ld is invalid\n", __func__, v);
+        } else {
+                iuu_vcc_set(port, v);
+                priv->vcc = v;
+        }
+fail_store_vcc_mode:
+        return count;
+}
+
+static DEVICE_ATTR(vcc_mode, S_IRUSR | S_IWUSR, show_vcc_mode,
+        store_vcc_mode);
+
+static int iuu_create_sysfs_attrs(struct usb_serial_port *port)
+{
+        dbg("%s", __func__);
+
+        return device_create_file(&port->dev, &dev_attr_vcc_mode);
+}
+
+static int iuu_remove_sysfs_attrs(struct usb_serial_port *port)
+{
+        dbg("%s", __func__);
+
+        device_remove_file(&port->dev, &dev_attr_vcc_mode);
+        return 0;
+}
+
+/*
+ * End Sysfs Attributes
+ */
+
 static struct usb_serial_driver iuu_device = {
         .driver = {
                    .owner = THIS_MODULE,
@@ -1189,6 +1277,8 @@ static struct usb_serial_driver iuu_device = {
                    },
         .id_table = id_table,
         .num_ports = 1,
+        .port_probe = iuu_create_sysfs_attrs,
+        .port_remove = iuu_remove_sysfs_attrs,
         .open = iuu_open,
         .close = iuu_close,
         .write = iuu_uart_write,
@@ -1238,14 +1328,19 @@ module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug enabled or not");
 
 module_param(xmas, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(xmas, "xmas color enabled or not");
+MODULE_PARM_DESC(xmas, "Xmas colors enabled or not");
 
 module_param(boost, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(boost, "overclock boost percent 100 to 500");
+MODULE_PARM_DESC(boost, "Card overclock boost (in percent 100-500)");
 
 module_param(clockmode, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(clockmode, "1=3Mhz579,2=3Mhz680,3=6Mhz");
+MODULE_PARM_DESC(clockmode, "Card clock mode (1=3.579 MHz, 2=3.680 MHz, "
+                "3=6 Mhz)");
 
 module_param(cdmode, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(cdmode, "Card detect mode 0=none, 1=CD, 2=!CD, 3=DSR, "
-                 "4=!DSR, 5=CTS, 6=!CTS, 7=RING, 8=!RING");
+MODULE_PARM_DESC(cdmode, "Card detect mode (0=none, 1=CD, 2=!CD, 3=DSR, "
+                 "4=!DSR, 5=CTS, 6=!CTS, 7=RING, 8=!RING)");
+
+module_param(vcc_default, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(vcc_default, "Set default VCC (either 3 for 3.3V or 5 "
+                "for 5V). Default to 5.");
diff --git a/drivers/usb/serial/moto_modem.c b/drivers/usb/serial/moto_modem.c
index b66b71ccd12b..99bd00f5188a 100644
--- a/drivers/usb/serial/moto_modem.c
+++ b/drivers/usb/serial/moto_modem.c
@@ -8,7 +8,7 @@
  *  published by the Free Software Foundation.
  *
  * {sigh}
- * Mororola should be using the CDC ACM USB spec, but instead
+ * Motorola should be using the CDC ACM USB spec, but instead
  * they try to just "do their own thing"...  This driver should handle a
  * few phones in which a basic "dumb serial connection" is needed to be
  * able to get a connection through to them.
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index fe47051dbef2..f66e39883218 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -291,6 +291,7 @@ static int  option_resume(struct usb_serial *serial);
 
 #define TELIT_VENDOR_ID                         0x1bc7
 #define TELIT_PRODUCT_UC864E                    0x1003
+#define TELIT_PRODUCT_UC864G                    0x1004
 
 /* ZTE PRODUCTS */
 #define ZTE_VENDOR_ID                           0x19d2
@@ -299,6 +300,7 @@ static int  option_resume(struct usb_serial *serial);
 #define ZTE_PRODUCT_MF626                       0x0031
 #define ZTE_PRODUCT_CDMA_TECH                   0xfffe
 #define ZTE_PRODUCT_AC8710                      0xfff1
+#define ZTE_PRODUCT_AC2726                      0xfff5
 
 #define BENQ_VENDOR_ID                          0x04a5
 #define BENQ_PRODUCT_H10                        0x4068
@@ -502,6 +504,7 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */
         { USB_DEVICE(MAXON_VENDOR_ID, 0x6280) }, /* BP3-USB & BP3-EXT HSDPA */
         { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864E) },
+        { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864G) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF622, 0xff, 0xff, 0xff) }, /* ZTE WCDMA products */
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0002, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0003, 0xff, 0xff, 0xff) },
@@ -571,6 +574,7 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0073, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC2726, 0xff, 0xff, 0xff) },
         { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) },
         { USB_DEVICE(DLINK_VENDOR_ID, DLINK_PRODUCT_DWM_652) },
         { USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H21_4512) },
@@ -592,6 +596,7 @@ static struct usb_driver option_driver = {
 #ifdef CONFIG_PM
         .suspend    = usb_serial_suspend,
         .resume     = usb_serial_resume,
+        .supports_autosuspend = 1,
 #endif
         .id_table   = option_ids,
         .no_dynamic_id =        1,
@@ -639,6 +644,12 @@ static int debug;
 #define IN_BUFLEN 4096
 #define OUT_BUFLEN 4096
 
+struct option_intf_private {
+        spinlock_t susp_lock;
+        unsigned int suspended:1;
+        int in_flight;
+};
+
 struct option_port_private {
         /* Input endpoints and buffer for this port */
         struct urb *in_urbs[N_IN_URB];
@@ -647,6 +658,8 @@ struct option_port_private {
         struct urb *out_urbs[N_OUT_URB];
         u8 *out_buffer[N_OUT_URB];
         unsigned long out_busy;         /* Bit vector of URBs in use */
+        int opened;
+        struct usb_anchor delayed;
 
         /* Settings for the port */
         int rts_state;  /* Handshaking pins (outputs) */
@@ -693,12 +706,17 @@ module_exit(option_exit);
 static int option_probe(struct usb_serial *serial,
                         const struct usb_device_id *id)
 {
+        struct option_intf_private *data;
         /* D-Link DWM 652 still exposes CD-Rom emulation interface in modem mode */
         if (serial->dev->descriptor.idVendor == DLINK_VENDOR_ID &&
                 serial->dev->descriptor.idProduct == DLINK_PRODUCT_DWM_652 &&
                 serial->interface->cur_altsetting->desc.bInterfaceClass == 0x8)
                 return -ENODEV;
 
+        data = serial->private = kzalloc(sizeof(struct option_intf_private), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+        spin_lock_init(&data->susp_lock);
         return 0;
 }
 
@@ -755,12 +773,15 @@ static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count)
 {
         struct option_port_private *portdata;
+        struct option_intf_private *intfdata;
         int i;
         int left, todo;
         struct urb *this_urb = NULL; /* spurious */
         int err;
+        unsigned long flags;
 
         portdata = usb_get_serial_port_data(port);
+        intfdata = port->serial->private;
 
         dbg("%s: write (%d chars)", __func__, count);
 
@@ -782,17 +803,33 @@ static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
                 dbg("%s: endpoint %d buf %d", __func__,
                         usb_pipeendpoint(this_urb->pipe), i);
 
+                err = usb_autopm_get_interface_async(port->serial->interface);
+                if (err < 0)
+                        break;
+
                 /* send the data */
                 memcpy(this_urb->transfer_buffer, buf, todo);
                 this_urb->transfer_buffer_length = todo;
 
-                err = usb_submit_urb(this_urb, GFP_ATOMIC);
-                if (err) {
-                        dbg("usb_submit_urb %p (write bulk) failed "
-                                "(%d)", this_urb, err);
-                        clear_bit(i, &portdata->out_busy);
-                        continue;
+                spin_lock_irqsave(&intfdata->susp_lock, flags);
+                if (intfdata->suspended) {
+                        usb_anchor_urb(this_urb, &portdata->delayed);
+                        spin_unlock_irqrestore(&intfdata->susp_lock, flags);
+                } else {
+                        intfdata->in_flight++;
+                        spin_unlock_irqrestore(&intfdata->susp_lock, flags);
+                        err = usb_submit_urb(this_urb, GFP_ATOMIC);
+                        if (err) {
+                                dbg("usb_submit_urb %p (write bulk) failed "
+                                        "(%d)", this_urb, err);
+                                clear_bit(i, &portdata->out_busy);
+                                spin_lock_irqsave(&intfdata->susp_lock, flags);
+                                intfdata->in_flight--;
+                                spin_unlock_irqrestore(&intfdata->susp_lock, flags);
+                                continue;
+                        }
                 }
+
                 portdata->tx_start_time[i] = jiffies;
                 buf += todo;
                 left -= todo;
@@ -836,7 +873,10 @@ static void option_indat_callback(struct urb *urb)
                         if (err)
                                 printk(KERN_ERR "%s: resubmit read urb failed. "
                                         "(%d)", __func__, err);
+                        else
+                                usb_mark_last_busy(port->serial->dev);
                 }
+
         }
         return;
 }
@@ -845,15 +885,21 @@ static void option_outdat_callback(struct urb *urb)
 {
         struct usb_serial_port *port;
         struct option_port_private *portdata;
+        struct option_intf_private *intfdata;
         int i;
 
         dbg("%s", __func__);
 
         port =  urb->context;
+        intfdata = port->serial->private;
 
         usb_serial_port_softint(port);
-
+        usb_autopm_put_interface_async(port->serial->interface);
         portdata = usb_get_serial_port_data(port);
+        spin_lock(&intfdata->susp_lock);
+        intfdata->in_flight--;
+        spin_unlock(&intfdata->susp_lock);
+
         for (i = 0; i < N_OUT_URB; ++i) {
                 if (portdata->out_urbs[i] == urb) {
                         smp_mb__before_clear_bit();
@@ -963,10 +1009,13 @@ static int option_chars_in_buffer(struct tty_struct *tty)
 static int option_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct option_port_private *portdata;
+        struct option_intf_private *intfdata;
+        struct usb_serial *serial = port->serial;
         int i, err;
         struct urb *urb;
 
         portdata = usb_get_serial_port_data(port);
+        intfdata = serial->private;
 
         dbg("%s", __func__);
 
@@ -985,6 +1034,12 @@ static int option_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         option_send_setup(port);
 
+        serial->interface->needs_remote_wakeup = 1;
+        spin_lock_irq(&intfdata->susp_lock);
+        portdata->opened = 1;
+        spin_unlock_irq(&intfdata->susp_lock);
+        usb_autopm_put_interface(serial->interface);
+
         return 0;
 }
 
@@ -1009,16 +1064,23 @@ static void option_close(struct usb_serial_port *port)
         int i;
         struct usb_serial *serial = port->serial;
         struct option_port_private *portdata;
+        struct option_intf_private *intfdata = port->serial->private;
 
         dbg("%s", __func__);
         portdata = usb_get_serial_port_data(port);
 
         if (serial->dev) {
                 /* Stop reading/writing urbs */
+                spin_lock_irq(&intfdata->susp_lock);
+                portdata->opened = 0;
+                spin_unlock_irq(&intfdata->susp_lock);
+
                 for (i = 0; i < N_IN_URB; i++)
                         usb_kill_urb(portdata->in_urbs[i]);
                 for (i = 0; i < N_OUT_URB; i++)
                         usb_kill_urb(portdata->out_urbs[i]);
+                usb_autopm_get_interface(serial->interface);
+                serial->interface->needs_remote_wakeup = 0;
         }
 }
 
@@ -1123,6 +1185,7 @@ static int option_startup(struct usb_serial *serial)
                                         __func__, i);
                         return 1;
                 }
+                init_usb_anchor(&portdata->delayed);
 
                 for (j = 0; j < N_IN_URB; j++) {
                         buffer = (u8 *)__get_free_page(GFP_KERNEL);
@@ -1225,18 +1288,52 @@ static void option_release(struct usb_serial *serial)
 #ifdef CONFIG_PM
 static int option_suspend(struct usb_serial *serial, pm_message_t message)
 {
+        struct option_intf_private *intfdata = serial->private;
+        int b;
+
         dbg("%s entered", __func__);
+
+        if (serial->dev->auto_pm) {
+                spin_lock_irq(&intfdata->susp_lock);
+                b = intfdata->in_flight;
+                spin_unlock_irq(&intfdata->susp_lock);
+
+                if (b)
+                        return -EBUSY;
+        }
+
+        spin_lock_irq(&intfdata->susp_lock);
+        intfdata->suspended = 1;
+        spin_unlock_irq(&intfdata->susp_lock);
         stop_read_write_urbs(serial);
 
         return 0;
 }
 
+static void play_delayed(struct usb_serial_port *port)
+{
+        struct option_intf_private *data;
+        struct option_port_private *portdata;
+        struct urb *urb;
+        int err;
+
+        portdata = usb_get_serial_port_data(port);
+        data = port->serial->private;
+        while ((urb = usb_get_from_anchor(&portdata->delayed))) {
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (!err)
+                        data->in_flight++;
+        }
+}
+
 static int option_resume(struct usb_serial *serial)
 {
-        int err, i, j;
+        int i, j;
         struct usb_serial_port *port;
-        struct urb *urb;
+        struct option_intf_private *intfdata = serial->private;
         struct option_port_private *portdata;
+        struct urb *urb;
+        int err = 0;
 
         dbg("%s entered", __func__);
         /* get the interrupt URBs resubmitted unconditionally */
@@ -1251,7 +1348,7 @@ static int option_resume(struct usb_serial *serial)
                 if (err < 0) {
                         err("%s: Error %d for interrupt URB of port%d",
                                  __func__, err, i);
-                        return err;
+                        goto err_out;
                 }
         }
 
@@ -1259,27 +1356,32 @@ static int option_resume(struct usb_serial *serial)
                 /* walk all ports */
                 port = serial->port[i];
                 portdata = usb_get_serial_port_data(port);
-                mutex_lock(&port->mutex);
 
                 /* skip closed ports */
-                if (!port->port.count) {
-                        mutex_unlock(&port->mutex);
+                spin_lock_irq(&intfdata->susp_lock);
+                if (!portdata->opened) {
+                        spin_unlock_irq(&intfdata->susp_lock);
                         continue;
                 }
 
                 for (j = 0; j < N_IN_URB; j++) {
                         urb = portdata->in_urbs[j];
-                        err = usb_submit_urb(urb, GFP_NOIO);
+                        err = usb_submit_urb(urb, GFP_ATOMIC);
                         if (err < 0) {
-                                mutex_unlock(&port->mutex);
                                 err("%s: Error %d for bulk URB %d",
                                          __func__, err, i);
-                                return err;
+                                spin_unlock_irq(&intfdata->susp_lock);
+                                goto err_out;
                         }
                 }
-                mutex_unlock(&port->mutex);
+                play_delayed(port);
+                spin_unlock_irq(&intfdata->susp_lock);
         }
-        return 0;
+        spin_lock_irq(&intfdata->susp_lock);
+        intfdata->suspended = 0;
+        spin_unlock_irq(&intfdata->susp_lock);
+err_out:
+        return err;
 }
 #endif
 
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index a63ea99936f7..1128e01525b1 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -96,6 +96,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
         { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
         { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
+        { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
 
@@ -527,6 +528,12 @@ static void pl2303_set_termios(struct tty_struct *tty,
         int baud;
         int i;
         u8 control;
+        const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
+                                 4800, 7200, 9600, 14400, 19200, 28800, 38400,
+                                 57600, 115200, 230400, 460800, 614400,
+                                 921600, 1228800, 2457600, 3000000, 6000000 };
+        int baud_floor, baud_ceil;
+        int k;
 
         dbg("%s -  port %d", __func__, port->number);
 
@@ -572,9 +579,39 @@ static void pl2303_set_termios(struct tty_struct *tty,
                 dbg("%s - data bits = %d", __func__, buf[6]);
         }
 
+        /* For reference buf[0]:buf[3] baud rate value */
+        /* NOTE: Only the values defined in baud_sup are supported !
+         *       => if unsupported values are set, the PL2303 seems to use
+         *          9600 baud (at least my PL2303X always does)
+         */
         baud = tty_get_baud_rate(tty);
-        dbg("%s - baud = %d", __func__, baud);
+        dbg("%s - baud requested = %d", __func__, baud);
         if (baud) {
+                /* Set baudrate to nearest supported value */
+                for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
+                        if (baud_sup[k] / baud) {
+                                baud_ceil = baud_sup[k];
+                                if (k==0) {
+                                        baud = baud_ceil;
+                                } else {
+                                        baud_floor = baud_sup[k-1];
+                                        if ((baud_ceil % baud)
+                                            > (baud % baud_floor))
+                                                baud = baud_floor;
+                                        else
+                                                baud = baud_ceil;
+                                }
+                                break;
+                        }
+                }
+                if (baud > 1228800) {
+                        /* type_0, type_1 only support up to 1228800 baud */
+                        if (priv->type != HX)
+                                baud = 1228800;
+                        else if (baud > 6000000)
+                                baud = 6000000;
+                }
+                dbg("%s - baud set = %d", __func__, baud);
                 buf[0] = baud & 0xff;
                 buf[1] = (baud >> 8) & 0xff;
                 buf[2] = (baud >> 16) & 0xff;
@@ -585,8 +622,16 @@ static void pl2303_set_termios(struct tty_struct *tty,
         /* For reference buf[4]=1 is 1.5 stop bits */
         /* For reference buf[4]=2 is 2 stop bits */
         if (cflag & CSTOPB) {
-                buf[4] = 2;
-                dbg("%s - stop bits = 2", __func__);
+                /* NOTE: Comply with "real" UARTs / RS232:
+                 *       use 1.5 instead of 2 stop bits with 5 data bits
+                 */
+                if ((cflag & CSIZE) == CS5) {
+                        buf[4] = 1;
+                        dbg("%s - stop bits = 1.5", __func__);
+                } else {
+                        buf[4] = 2;
+                        dbg("%s - stop bits = 2", __func__);
+                }
         } else {
                 buf[4] = 0;
                 dbg("%s - stop bits = 1", __func__);
@@ -599,11 +644,21 @@ static void pl2303_set_termios(struct tty_struct *tty,
                 /* For reference buf[5]=3 is mark parity */
                 /* For reference buf[5]=4 is space parity */
                 if (cflag & PARODD) {
-                        buf[5] = 1;
-                        dbg("%s - parity = odd", __func__);
+                        if (cflag & CMSPAR) {
+                                buf[5] = 3;
+                                dbg("%s - parity = mark", __func__);
+                        } else {
+                                buf[5] = 1;
+                                dbg("%s - parity = odd", __func__);
+                        }
                 } else {
-                        buf[5] = 2;
-                        dbg("%s - parity = even", __func__);
+                        if (cflag & CMSPAR) {
+                                buf[5] = 4;
+                                dbg("%s - parity = space", __func__);
+                        } else {
+                                buf[5] = 2;
+                                dbg("%s - parity = even", __func__);
+                        }
                 }
         } else {
                 buf[5] = 0;
@@ -647,7 +702,7 @@ static void pl2303_set_termios(struct tty_struct *tty,
                 pl2303_vendor_write(0x0, 0x0, serial);
         }
 
-        /* FIXME: Need to read back resulting baud rate */
+        /* Save resulting baud rate */
         if (baud)
                 tty_encode_baud_rate(tty, baud, baud);
 
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index ee9505e1dd92..d640dc951568 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -130,3 +130,7 @@
 /* Sony, USB data cable for CMD-Jxx mobile phones */
 #define SONY_VENDOR_ID          0x054c
 #define SONY_QN3USB_PRODUCT_ID  0x0437
+
+/* Sanwa KB-USB2 multimeter cable (ID: 11ad:0001) */
+#define SANWA_VENDOR_ID         0x11ad
+#define SANWA_PRODUCT_ID        0x0001
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index 55391bbe1230..68fa0e43b781 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -51,6 +51,12 @@ struct sierra_iface_info {
         const u8  *ifaceinfo;   /* pointer to the array holding the numbers */
 };
 
+struct sierra_intf_private {
+        spinlock_t susp_lock;
+        unsigned int suspended:1;
+        int in_flight;
+};
+
 static int sierra_set_power_state(struct usb_device *udev, __u16 swiState)
 {
         int result;
@@ -144,6 +150,7 @@ static int sierra_probe(struct usb_serial *serial,
 {
         int result = 0;
         struct usb_device *udev;
+        struct sierra_intf_private *data;
         u8 ifnum;
 
         udev = serial->dev;
@@ -171,6 +178,11 @@ static int sierra_probe(struct usb_serial *serial,
                 return -ENODEV;
         }
 
+        data = serial->private = kzalloc(sizeof(struct sierra_intf_private), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+        spin_lock_init(&data->susp_lock);
+
         return result;
 }
 
@@ -261,13 +273,18 @@ static struct usb_driver sierra_driver = {
         .name       = "sierra",
         .probe      = usb_serial_probe,
         .disconnect = usb_serial_disconnect,
+        .suspend    = usb_serial_suspend,
+        .resume     = usb_serial_resume,
         .id_table   = id_table,
         .no_dynamic_id =        1,
+        .supports_autosuspend = 1,
 };
 
 struct sierra_port_private {
         spinlock_t lock;        /* lock the structure */
         int outstanding_urbs;   /* number of out urbs in flight */
+        struct usb_anchor active;
+        struct usb_anchor delayed;
 
         /* Input endpoints and buffers for this port */
         struct urb *in_urbs[N_IN_URB];
@@ -279,6 +296,8 @@ struct sierra_port_private {
         int dsr_state;
         int dcd_state;
         int ri_state;
+
+        unsigned int opened:1;
 };
 
 static int sierra_send_setup(struct usb_serial_port *port)
@@ -390,21 +409,25 @@ static void sierra_outdat_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+        struct sierra_intf_private *intfdata;
         int status = urb->status;
-        unsigned long flags;
 
         dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
+        intfdata = port->serial->private;
 
         /* free up the transfer buffer, as usb_free_urb() does not do this */
         kfree(urb->transfer_buffer);
-
+        usb_autopm_put_interface_async(port->serial->interface);
         if (status)
                 dev_dbg(&port->dev, "%s - nonzero write bulk status "
                     "received: %d\n", __func__, status);
 
-        spin_lock_irqsave(&portdata->lock, flags);
+        spin_lock(&portdata->lock);
         --portdata->outstanding_urbs;
-        spin_unlock_irqrestore(&portdata->lock, flags);
+        spin_unlock(&portdata->lock);
+        spin_lock(&intfdata->susp_lock);
+        --intfdata->in_flight;
+        spin_unlock(&intfdata->susp_lock);
 
         usb_serial_port_softint(port);
 }
@@ -414,6 +437,7 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
                                         const unsigned char *buf, int count)
 {
         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+        struct sierra_intf_private *intfdata;
         struct usb_serial *serial = port->serial;
         unsigned long flags;
         unsigned char *buffer;
@@ -426,9 +450,9 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
                 return 0;
 
         portdata = usb_get_serial_port_data(port);
+        intfdata = serial->private;
 
         dev_dbg(&port->dev, "%s: write (%zd bytes)\n", __func__, writesize);
-
         spin_lock_irqsave(&portdata->lock, flags);
         dev_dbg(&port->dev, "%s - outstanding_urbs: %d\n", __func__,
                 portdata->outstanding_urbs);
@@ -442,6 +466,14 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
                 portdata->outstanding_urbs);
         spin_unlock_irqrestore(&portdata->lock, flags);
 
+        retval = usb_autopm_get_interface_async(serial->interface);
+        if (retval < 0) {
+                spin_lock_irqsave(&portdata->lock, flags);
+                portdata->outstanding_urbs--;
+                spin_unlock_irqrestore(&portdata->lock, flags);
+                goto error_simple;
+        }
+
         buffer = kmalloc(writesize, GFP_ATOMIC);
         if (!buffer) {
                 dev_err(&port->dev, "out of memory\n");
@@ -468,14 +500,29 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
         /* Handle the need to send a zero length packet */
         urb->transfer_flags |= URB_ZERO_PACKET;
 
+        spin_lock_irqsave(&intfdata->susp_lock, flags);
+
+        if (intfdata->suspended) {
+                usb_anchor_urb(urb, &portdata->delayed);
+                spin_unlock_irqrestore(&intfdata->susp_lock, flags);
+                goto skip_power;
+        } else {
+                usb_anchor_urb(urb, &portdata->active);
+        }
         /* send it down the pipe */
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval) {
+                usb_unanchor_urb(urb);
+                spin_unlock_irqrestore(&intfdata->susp_lock, flags);
                 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed "
                         "with status = %d\n", __func__, retval);
                 goto error;
+        } else {
+                intfdata->in_flight++;
+                spin_unlock_irqrestore(&intfdata->susp_lock, flags);
         }
 
+skip_power:
         /* we are done with this urb, so let the host driver
          * really free it when it is finished with it */
         usb_free_urb(urb);
@@ -491,6 +538,8 @@ error_no_buffer:
         dev_dbg(&port->dev, "%s - 2. outstanding_urbs: %d\n", __func__,
                 portdata->outstanding_urbs);
         spin_unlock_irqrestore(&portdata->lock, flags);
+        usb_autopm_put_interface_async(serial->interface);
+error_simple:
         return retval;
 }
 
@@ -530,6 +579,7 @@ static void sierra_indat_callback(struct urb *urb)
 
         /* Resubmit urb so we continue receiving */
         if (port->port.count && status != -ESHUTDOWN && status != -EPERM) {
+                usb_mark_last_busy(port->serial->dev);
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err)
                         dev_err(&port->dev, "resubmit read urb failed."
@@ -591,6 +641,7 @@ static void sierra_instat_callback(struct urb *urb)
 
         /* Resubmit urb so we continue receiving IRQ data */
         if (port->port.count && status != -ESHUTDOWN && status != -ENOENT) {
+                usb_mark_last_busy(serial->dev);
                 urb->dev = serial->dev;
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err)
@@ -711,6 +762,8 @@ static void sierra_close(struct usb_serial_port *port)
         int i;
         struct usb_serial *serial = port->serial;
         struct sierra_port_private *portdata;
+        struct sierra_intf_private *intfdata = port->serial->private;
+
 
         dev_dbg(&port->dev, "%s\n", __func__);
         portdata = usb_get_serial_port_data(port);
@@ -723,6 +776,10 @@ static void sierra_close(struct usb_serial_port *port)
                 if (!serial->disconnected)
                         sierra_send_setup(port);
                 mutex_unlock(&serial->disc_mutex);
+                spin_lock_irq(&intfdata->susp_lock);
+                portdata->opened = 0;
+                spin_unlock_irq(&intfdata->susp_lock);
+
 
                 /* Stop reading urbs */
                 sierra_stop_rx_urbs(port);
@@ -731,6 +788,8 @@ static void sierra_close(struct usb_serial_port *port)
                         sierra_release_urb(portdata->in_urbs[i]);
                         portdata->in_urbs[i] = NULL;
                 }
+                usb_autopm_get_interface(serial->interface);
+                serial->interface->needs_remote_wakeup = 0;
         }
 }
 
@@ -738,6 +797,7 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct sierra_port_private *portdata;
         struct usb_serial *serial = port->serial;
+        struct sierra_intf_private *intfdata = serial->private;
         int i;
         int err;
         int endpoint;
@@ -771,6 +831,12 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
         }
         sierra_send_setup(port);
 
+        serial->interface->needs_remote_wakeup = 1;
+        spin_lock_irq(&intfdata->susp_lock);
+        portdata->opened = 1;
+        spin_unlock_irq(&intfdata->susp_lock);
+        usb_autopm_put_interface(serial->interface);
+
         return 0;
 }
 
@@ -818,6 +884,8 @@ static int sierra_startup(struct usb_serial *serial)
                         return -ENOMEM;
                 }
                 spin_lock_init(&portdata->lock);
+                init_usb_anchor(&portdata->active);
+                init_usb_anchor(&portdata->delayed);
                 /* Set the port private data pointer */
                 usb_set_serial_port_data(port, portdata);
         }
@@ -844,6 +912,83 @@ static void sierra_release(struct usb_serial *serial)
         }
 }
 
+static void stop_read_write_urbs(struct usb_serial *serial)
+{
+        int i, j;
+        struct usb_serial_port *port;
+        struct sierra_port_private *portdata;
+
+        /* Stop reading/writing urbs */
+        for (i = 0; i < serial->num_ports; ++i) {
+                port = serial->port[i];
+                portdata = usb_get_serial_port_data(port);
+                for (j = 0; j < N_IN_URB; j++)
+                        usb_kill_urb(portdata->in_urbs[j]);
+                usb_kill_anchored_urbs(&portdata->active);
+        }
+}
+
+static int sierra_suspend(struct usb_serial *serial, pm_message_t message)
+{
+        struct sierra_intf_private *intfdata;
+        int b;
+
+        if (serial->dev->auto_pm) {
+                intfdata = serial->private;
+                spin_lock_irq(&intfdata->susp_lock);
+                b = intfdata->in_flight;
+
+                if (b) {
+                        spin_unlock_irq(&intfdata->susp_lock);
+                        return -EBUSY;
+                } else {
+                        intfdata->suspended = 1;
+                        spin_unlock_irq(&intfdata->susp_lock);
+                }
+        }
+        stop_read_write_urbs(serial);
+
+        return 0;
+}
+
+static int sierra_resume(struct usb_serial *serial)
+{
+        struct usb_serial_port *port;
+        struct sierra_intf_private *intfdata = serial->private;
+        struct sierra_port_private *portdata;
+        struct urb *urb;
+        int ec = 0;
+        int i, err;
+
+        spin_lock_irq(&intfdata->susp_lock);
+        for (i = 0; i < serial->num_ports; i++) {
+                port = serial->port[i];
+                portdata = usb_get_serial_port_data(port);
+
+                while ((urb = usb_get_from_anchor(&portdata->delayed))) {
+                        usb_anchor_urb(urb, &portdata->active);
+                        intfdata->in_flight++;
+                        err = usb_submit_urb(urb, GFP_ATOMIC);
+                        if (err < 0) {
+                                intfdata->in_flight--;
+                                usb_unanchor_urb(urb);
+                                usb_scuttle_anchored_urbs(&portdata->delayed);
+                                break;
+                        }
+                }
+
+                if (portdata->opened) {
+                        err = sierra_submit_rx_urbs(port, GFP_ATOMIC);
+                        if (err)
+                                ec++;
+                }
+        }
+        intfdata->suspended = 0;
+        spin_unlock_irq(&intfdata->susp_lock);
+
+        return ec ? -EIO : 0;
+}
+
 static struct usb_serial_driver sierra_device = {
         .driver = {
                 .owner =        THIS_MODULE,
@@ -864,6 +1009,8 @@ static struct usb_serial_driver sierra_device = {
         .tiocmset          = sierra_tiocmset,
         .attach            = sierra_startup,
         .release           = sierra_release,
+        .suspend           = sierra_suspend,
+        .resume            = sierra_resume,
         .read_int_callback = sierra_instat_callback,
 };
 
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 9d7ca4868d37..ff75a3589e7e 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -35,6 +35,7 @@
 #include <linux/serial.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/kfifo.h>
 #include "pl2303.h"
 
 /*
@@ -292,8 +293,6 @@ static int serial_open(struct tty_struct *tty, struct file *filp)
 static void serial_down(struct usb_serial_port *port)
 {
         struct usb_serial_driver *drv = port->serial->type;
-        struct usb_serial *serial;
-        struct module *owner;
 
         /*
          * The console is magical.  Do not hang up the console hardware
@@ -309,12 +308,8 @@ static void serial_down(struct usb_serial_port *port)
                 return;
 
         mutex_lock(&port->mutex);
-        serial = port->serial;
-        owner = serial->type->driver.owner;
-
         if (drv->close)
                 drv->close(port);
-
         mutex_unlock(&port->mutex);
 }
 
@@ -631,6 +626,8 @@ static void port_release(struct device *dev)
         usb_free_urb(port->write_urb);
         usb_free_urb(port->interrupt_in_urb);
         usb_free_urb(port->interrupt_out_urb);
+        if (!IS_ERR(port->write_fifo) && port->write_fifo)
+                kfifo_free(port->write_fifo);
         kfree(port->bulk_in_buffer);
         kfree(port->bulk_out_buffer);
         kfree(port->interrupt_in_buffer);
@@ -970,6 +967,10 @@ int usb_serial_probe(struct usb_interface *interface,
                         dev_err(&interface->dev, "No free urbs available\n");
                         goto probe_error;
                 }
+                port->write_fifo = kfifo_alloc(PAGE_SIZE, GFP_KERNEL,
+                        &port->lock);
+                if (IS_ERR(port->write_fifo))
+                        goto probe_error;
                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
                 port->bulk_out_size = buffer_size;
                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
@@ -1163,15 +1164,19 @@ int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
 
         serial->suspending = 1;
 
+        if (serial->type->suspend) {
+                r = serial->type->suspend(serial, message);
+                if (r < 0)
+                        goto err_out;
+        }
+
         for (i = 0; i < serial->num_ports; ++i) {
                 port = serial->port[i];
                 if (port)
                         kill_traffic(port);
         }
 
-        if (serial->type->suspend)
-                r = serial->type->suspend(serial, message);
-
+err_out:
         return r;
 }
 EXPORT_SYMBOL(usb_serial_suspend);
diff --git a/drivers/usb/storage/datafab.c b/drivers/usb/storage/datafab.c
index 2b6e565262c2..ded836b02d7b 100644
--- a/drivers/usb/storage/datafab.c
+++ b/drivers/usb/storage/datafab.c
@@ -334,7 +334,7 @@ static int datafab_determine_lun(struct us_data *us,
         unsigned char *buf;
         int count = 0, rc;
 
-        if (!us || !info)
+        if (!info)
                 return USB_STOR_TRANSPORT_ERROR;
 
         memcpy(command, scommand, 8);
@@ -399,7 +399,7 @@ static int datafab_id_device(struct us_data *us,
         unsigned char *reply;
         int rc;
 
-        if (!us || !info)
+        if (!info)
                 return USB_STOR_TRANSPORT_ERROR;
 
         if (info->lun == -1) {
diff --git a/drivers/usb/storage/initializers.c b/drivers/usb/storage/initializers.c
index ec17c96371af..105d900150c1 100644
--- a/drivers/usb/storage/initializers.c
+++ b/drivers/usb/storage/initializers.c
@@ -102,5 +102,5 @@ int usb_stor_huawei_e220_init(struct us_data *us)
                                       USB_TYPE_STANDARD | USB_RECIP_DEVICE,
                                       0x01, 0x0, NULL, 0x0, 1000);
         US_DEBUGP("Huawei mode set result is %d\n", result);
-        return (result ? 0 : -ENODEV);
+        return 0;
 }
diff --git a/drivers/usb/storage/jumpshot.c b/drivers/usb/storage/jumpshot.c
index 1c69420e3acf..6168596c5ac6 100644
--- a/drivers/usb/storage/jumpshot.c
+++ b/drivers/usb/storage/jumpshot.c
@@ -335,7 +335,7 @@ static int jumpshot_id_device(struct us_data *us,
         unsigned char *reply;
         int      rc;
 
-        if (!us || !info)
+        if (!info)
                 return USB_STOR_TRANSPORT_ERROR;
 
         command[0] = 0xE0;
diff --git a/drivers/usb/storage/onetouch.c b/drivers/usb/storage/onetouch.c
index 380233bd6a39..80e65f29921c 100644
--- a/drivers/usb/storage/onetouch.c
+++ b/drivers/usb/storage/onetouch.c
@@ -163,7 +163,7 @@ static void usb_onetouch_pm_hook(struct us_data *us, int action)
                         usb_kill_urb(onetouch->irq);
                         break;
                 case US_RESUME:
-                        if (usb_submit_urb(onetouch->irq, GFP_KERNEL) != 0)
+                        if (usb_submit_urb(onetouch->irq, GFP_NOIO) != 0)
                                 dev_err(&onetouch->irq->dev->dev,
                                         "usb_submit_urb failed\n");
                         break;
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 7477d411959f..079ae0f7bec1 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -66,13 +66,6 @@ UNUSUAL_DEV(  0x03eb, 0x2002, 0x0100, 0x0100,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE),
 
-/* modified by Tobias Lorenz <tobias.lorenz@gmx.net> */
-UNUSUAL_DEV(  0x03ee, 0x6901, 0x0000, 0x0200,
-                "Mitsumi",
-                "USB FDD",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_SINGLE_LUN ),
-
 /* Reported by Rodolfo Quesada <rquesada@roqz.net> */
 UNUSUAL_DEV(  0x03ee, 0x6906, 0x0003, 0x0003,
                 "VIA Technologies Inc.",
@@ -233,13 +226,6 @@ UNUSUAL_DEV(  0x0421, 0x0495, 0x0370, 0x0370,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64 ),
 
-/* Reported by Olaf Hering <olh@suse.de> from novell bug #105878 */
-UNUSUAL_DEV(  0x0424, 0x0fdc, 0x0210, 0x0210,
-                "SMSC",
-                "FDC GOLD-2.30",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_SINGLE_LUN ),
-
 #ifdef NO_SDDR09
 UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
                 "Microtech",
@@ -664,19 +650,13 @@ UNUSUAL_DEV(  0x055d, 0x2020, 0x0000, 0x0210,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
-                
+/* We keep this entry to force the transport; firmware 3.00 and later is ok. */
 UNUSUAL_DEV(  0x057b, 0x0000, 0x0000, 0x0299,
                 "Y-E Data",
                 "Flashbuster-U",
                 US_SC_DEVICE,  US_PR_CB, NULL,
                 US_FL_SINGLE_LUN),
 
-UNUSUAL_DEV(  0x057b, 0x0000, 0x0300, 0x9999,
-                "Y-E Data",
-                "Flashbuster-U",
-                US_SC_DEVICE,  US_PR_DEVICE, NULL,
-                US_FL_SINGLE_LUN),
-
 /* Reported by Johann Cardon <johann.cardon@free.fr>
  * This entry is needed only because the device reports
  * bInterfaceClass = 0xff (vendor-specific)
diff --git a/drivers/usb/usb-skeleton.c b/drivers/usb/usb-skeleton.c
index 60ba631e99c2..b62f2bc064f6 100644
--- a/drivers/usb/usb-skeleton.c
+++ b/drivers/usb/usb-skeleton.c
@@ -18,7 +18,7 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kref.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/mutex.h>
 
@@ -28,7 +28,7 @@
 #define USB_SKEL_PRODUCT_ID     0xfff0
 
 /* table of devices that work with this driver */
-static struct usb_device_id skel_table [] = {
+static struct usb_device_id skel_table[] = {
         { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
@@ -52,15 +52,21 @@ struct usb_skel {
         struct usb_interface    *interface;             /* the interface for this device */
         struct semaphore        limit_sem;              /* limiting the number of writes in progress */
         struct usb_anchor       submitted;              /* in case we need to retract our submissions */
+        struct urb              *bulk_in_urb;           /* the urb to read data with */
         unsigned char           *bulk_in_buffer;        /* the buffer to receive data */
         size_t                  bulk_in_size;           /* the size of the receive buffer */
+        size_t                  bulk_in_filled;         /* number of bytes in the buffer */
+        size_t                  bulk_in_copied;         /* already copied to user space */
         __u8                    bulk_in_endpointAddr;   /* the address of the bulk in endpoint */
         __u8                    bulk_out_endpointAddr;  /* the address of the bulk out endpoint */
         int                     errors;                 /* the last request tanked */
         int                     open_count;             /* count the number of openers */
+        bool                    ongoing_read;           /* a read is going on */
+        bool                    processed_urb;          /* indicates we haven't processed the urb */
         spinlock_t              err_lock;               /* lock for errors */
         struct kref             kref;
         struct mutex            io_mutex;               /* synchronize I/O with disconnect */
+        struct completion       bulk_in_completion;     /* to wait for an ongoing read */
 };
 #define to_skel_dev(d) container_of(d, struct usb_skel, kref)
 
@@ -71,6 +77,7 @@ static void skel_delete(struct kref *kref)
 {
         struct usb_skel *dev = to_skel_dev(kref);
 
+        usb_free_urb(dev->bulk_in_urb);
         usb_put_dev(dev->udev);
         kfree(dev->bulk_in_buffer);
         kfree(dev);
@@ -87,7 +94,7 @@ static int skel_open(struct inode *inode, struct file *file)
 
         interface = usb_find_interface(&skel_driver, subminor);
         if (!interface) {
-                err ("%s - error, can't find device for minor %d",
+                err("%s - error, can't find device for minor %d",
                      __func__, subminor);
                 retval = -ENODEV;
                 goto exit;
@@ -174,38 +181,190 @@ static int skel_flush(struct file *file, fl_owner_t id)
         return res;
 }
 
-static ssize_t skel_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
+static void skel_read_bulk_callback(struct urb *urb)
 {
         struct usb_skel *dev;
-        int retval;
-        int bytes_read;
+
+        dev = urb->context;
+
+        spin_lock(&dev->err_lock);
+        /* sync/async unlink faults aren't errors */
+        if (urb->status) {
+                if (!(urb->status == -ENOENT ||
+                    urb->status == -ECONNRESET ||
+                    urb->status == -ESHUTDOWN))
+                        err("%s - nonzero write bulk status received: %d",
+                            __func__, urb->status);
+
+                dev->errors = urb->status;
+        } else {
+                dev->bulk_in_filled = urb->actual_length;
+        }
+        dev->ongoing_read = 0;
+        spin_unlock(&dev->err_lock);
+
+        complete(&dev->bulk_in_completion);
+}
+
+static int skel_do_read_io(struct usb_skel *dev, size_t count)
+{
+        int rv;
+
+        /* prepare a read */
+        usb_fill_bulk_urb(dev->bulk_in_urb,
+                        dev->udev,
+                        usb_rcvbulkpipe(dev->udev,
+                                dev->bulk_in_endpointAddr),
+                        dev->bulk_in_buffer,
+                        min(dev->bulk_in_size, count),
+                        skel_read_bulk_callback,
+                        dev);
+        /* tell everybody to leave the URB alone */
+        spin_lock_irq(&dev->err_lock);
+        dev->ongoing_read = 1;
+        spin_unlock_irq(&dev->err_lock);
+
+        /* do it */
+        rv = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL);
+        if (rv < 0) {
+                err("%s - failed submitting read urb, error %d",
+                        __func__, rv);
+                dev->bulk_in_filled = 0;
+                rv = (rv == -ENOMEM) ? rv : -EIO;
+                spin_lock_irq(&dev->err_lock);
+                dev->ongoing_read = 0;
+                spin_unlock_irq(&dev->err_lock);
+        }
+
+        return rv;
+}
+
+static ssize_t skel_read(struct file *file, char *buffer, size_t count,
+                         loff_t *ppos)
+{
+        struct usb_skel *dev;
+        int rv;
+        bool ongoing_io;
 
         dev = (struct usb_skel *)file->private_data;
 
-        mutex_lock(&dev->io_mutex);
+        /* if we cannot read at all, return EOF */
+        if (!dev->bulk_in_urb || !count)
+                return 0;
+
+        /* no concurrent readers */
+        rv = mutex_lock_interruptible(&dev->io_mutex);
+        if (rv < 0)
+                return rv;
+
         if (!dev->interface) {          /* disconnect() was called */
-                retval = -ENODEV;
+                rv = -ENODEV;
                 goto exit;
         }
 
-        /* do a blocking bulk read to get data from the device */
-        retval = usb_bulk_msg(dev->udev,
-                              usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
-                              dev->bulk_in_buffer,
-                              min(dev->bulk_in_size, count),
-                              &bytes_read, 10000);
-
-        /* if the read was successful, copy the data to userspace */
-        if (!retval) {
-                if (copy_to_user(buffer, dev->bulk_in_buffer, bytes_read))
-                        retval = -EFAULT;
-                else
-                        retval = bytes_read;
+        /* if IO is under way, we must not touch things */
+retry:
+        spin_lock_irq(&dev->err_lock);
+        ongoing_io = dev->ongoing_read;
+        spin_unlock_irq(&dev->err_lock);
+
+        if (ongoing_io) {
+                /* nonblocking IO shall not wait */
+                if (file->f_flags & O_NONBLOCK) {
+                        rv = -EAGAIN;
+                        goto exit;
+                }
+                /*
+                 * IO may take forever
+                 * hence wait in an interruptible state
+                 */
+                rv = wait_for_completion_interruptible(&dev->bulk_in_completion);
+                if (rv < 0)
+                        goto exit;
+                /*
+                 * by waiting we also semiprocessed the urb
+                 * we must finish now
+                 */
+                dev->bulk_in_copied = 0;
+                dev->processed_urb = 1;
+        }
+
+        if (!dev->processed_urb) {
+                /*
+                 * the URB hasn't been processed
+                 * do it now
+                 */
+                wait_for_completion(&dev->bulk_in_completion);
+                dev->bulk_in_copied = 0;
+                dev->processed_urb = 1;
+        }
+
+        /* errors must be reported */
+        rv = dev->errors;
+        if (rv < 0) {
+                /* any error is reported once */
+                dev->errors = 0;
+                /* to preserve notifications about reset */
+                rv = (rv == -EPIPE) ? rv : -EIO;
+                /* no data to deliver */
+                dev->bulk_in_filled = 0;
+                /* report it */
+                goto exit;
         }
 
+        /*
+         * if the buffer is filled we may satisfy the read
+         * else we need to start IO
+         */
+
+        if (dev->bulk_in_filled) {
+                /* we had read data */
+                size_t available = dev->bulk_in_filled - dev->bulk_in_copied;
+                size_t chunk = min(available, count);
+
+                if (!available) {
+                        /*
+                         * all data has been used
+                         * actual IO needs to be done
+                         */
+                        rv = skel_do_read_io(dev, count);
+                        if (rv < 0)
+                                goto exit;
+                        else
+                                goto retry;
+                }
+                /*
+                 * data is available
+                 * chunk tells us how much shall be copied
+                 */
+
+                if (copy_to_user(buffer,
+                                 dev->bulk_in_buffer + dev->bulk_in_copied,
+                                 chunk))
+                        rv = -EFAULT;
+                else
+                        rv = chunk;
+
+                dev->bulk_in_copied += chunk;
+
+                /*
+                 * if we are asked for more than we have,
+                 * we start IO but don't wait
+                 */
+                if (available < count)
+                        skel_do_read_io(dev, count - chunk);
+        } else {
+                /* no data in the buffer */
+                rv = skel_do_read_io(dev, count);
+                if (rv < 0)
+                        goto exit;
+                else if (!file->f_flags & O_NONBLOCK)
+                        goto retry;
+                rv = -EAGAIN;
+        }
 exit:
         mutex_unlock(&dev->io_mutex);
-        return retval;
+        return rv;
 }
 
 static void skel_write_bulk_callback(struct urb *urb)
@@ -216,7 +375,7 @@ static void skel_write_bulk_callback(struct urb *urb)
 
         /* sync/async unlink faults aren't errors */
         if (urb->status) {
-                if(!(urb->status == -ENOENT ||
+                if (!(urb->status == -ENOENT ||
                     urb->status == -ECONNRESET ||
                     urb->status == -ESHUTDOWN))
                         err("%s - nonzero write bulk status received: %d",
@@ -233,7 +392,8 @@ static void skel_write_bulk_callback(struct urb *urb)
         up(&dev->limit_sem);
 }
 
-static ssize_t skel_write(struct file *file, const char *user_buffer, size_t count, loff_t *ppos)
+static ssize_t skel_write(struct file *file, const char *user_buffer,
+                          size_t count, loff_t *ppos)
 {
         struct usb_skel *dev;
         int retval = 0;
@@ -247,14 +407,25 @@ static ssize_t skel_write(struct file *file, const char *user_buffer, size_t cou
         if (count == 0)
                 goto exit;
 
-        /* limit the number of URBs in flight to stop a user from using up all RAM */
-        if (down_interruptible(&dev->limit_sem)) {
-                retval = -ERESTARTSYS;
-                goto exit;
+        /*
+         * limit the number of URBs in flight to stop a user from using up all
+         * RAM
+         */
+        if (!file->f_flags & O_NONBLOCK) {
+                if (down_interruptible(&dev->limit_sem)) {
+                        retval = -ERESTARTSYS;
+                        goto exit;
+                }
+        } else {
+                if (down_trylock(&dev->limit_sem)) {
+                        retval = -EAGAIN;
+                        goto exit;
+                }
         }
 
         spin_lock_irq(&dev->err_lock);
-        if ((retval = dev->errors) < 0) {
+        retval = dev->errors;
+        if (retval < 0) {
                 /* any error is reported once */
                 dev->errors = 0;
                 /* to preserve notifications about reset */
@@ -271,7 +442,8 @@ static ssize_t skel_write(struct file *file, const char *user_buffer, size_t cou
                 goto error;
         }
 
-        buf = usb_buffer_alloc(dev->udev, writesize, GFP_KERNEL, &urb->transfer_dma);
+        buf = usb_buffer_alloc(dev->udev, writesize, GFP_KERNEL,
+                               &urb->transfer_dma);
         if (!buf) {
                 retval = -ENOMEM;
                 goto error;
@@ -301,11 +473,15 @@ static ssize_t skel_write(struct file *file, const char *user_buffer, size_t cou
         retval = usb_submit_urb(urb, GFP_KERNEL);
         mutex_unlock(&dev->io_mutex);
         if (retval) {
-                err("%s - failed submitting write urb, error %d", __func__, retval);
+                err("%s - failed submitting write urb, error %d", __func__,
+                    retval);
                 goto error_unanchor;
         }
 
-        /* release our reference to this urb, the USB core will eventually free it entirely */
+        /*
+         * release our reference to this urb, the USB core will eventually free
+         * it entirely
+         */
         usb_free_urb(urb);
 
 
@@ -343,7 +519,8 @@ static struct usb_class_driver skel_class = {
         .minor_base =   USB_SKEL_MINOR_BASE,
 };
 
-static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
+static int skel_probe(struct usb_interface *interface,
+                      const struct usb_device_id *id)
 {
         struct usb_skel *dev;
         struct usb_host_interface *iface_desc;
@@ -363,6 +540,7 @@ static int skel_probe(struct usb_interface *interface, const struct usb_device_i
         mutex_init(&dev->io_mutex);
         spin_lock_init(&dev->err_lock);
         init_usb_anchor(&dev->submitted);
+        init_completion(&dev->bulk_in_completion);
 
         dev->udev = usb_get_dev(interface_to_usbdev(interface));
         dev->interface = interface;
@@ -384,6 +562,11 @@ static int skel_probe(struct usb_interface *interface, const struct usb_device_i
                                 err("Could not allocate bulk_in_buffer");
                                 goto error;
                         }
+                        dev->bulk_in_urb = usb_alloc_urb(0, GFP_KERNEL);
+                        if (!dev->bulk_in_urb) {
+                                err("Could not allocate bulk_in_urb");
+                                goto error;
+                        }
                 }
 
                 if (!dev->bulk_out_endpointAddr &&
@@ -453,6 +636,7 @@ static void skel_draw_down(struct usb_skel *dev)
         time = usb_wait_anchor_empty_timeout(&dev->submitted, 1000);
         if (!time)
                 usb_kill_anchored_urbs(&dev->submitted);
+        usb_kill_urb(dev->bulk_in_urb);
 }
 
 static int skel_suspend(struct usb_interface *intf, pm_message_t message)
@@ -465,7 +649,7 @@ static int skel_suspend(struct usb_interface *intf, pm_message_t message)
         return 0;
 }
 
-static int skel_resume (struct usb_interface *intf)
+static int skel_resume(struct usb_interface *intf)
 {
         return 0;
 }
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 19fabc487beb..a34fa89f1474 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -195,7 +195,7 @@ struct usb_interface {
 
         struct device dev;              /* interface specific device info */
         struct device *usb_dev;
-        int pm_usage_cnt;               /* usage counter for autosuspend */
+        atomic_t pm_usage_cnt;          /* usage counter for autosuspend */
         struct work_struct reset_ws;    /* for resets in atomic context */
 };
 #define to_usb_interface(d) container_of(d, struct usb_interface, dev)
@@ -551,13 +551,13 @@ extern void usb_autopm_put_interface_async(struct usb_interface *intf);
 
 static inline void usb_autopm_enable(struct usb_interface *intf)
 {
-        intf->pm_usage_cnt = 0;
+        atomic_set(&intf->pm_usage_cnt, 0);
         usb_autopm_set_interface(intf);
 }
 
 static inline void usb_autopm_disable(struct usb_interface *intf)
 {
-        intf->pm_usage_cnt = 1;
+        atomic_set(&intf->pm_usage_cnt, 1);
         usb_autopm_set_interface(intf);
 }
 
@@ -1036,9 +1036,10 @@ typedef void (*usb_complete_t)(struct urb *);
  * @transfer_flags: A variety of flags may be used to affect how URB
  *      submission, unlinking, or operation are handled.  Different
  *      kinds of URB can use different flags.
- * @transfer_buffer:  This identifies the buffer to (or from) which
- *      the I/O request will be performed (unless URB_NO_TRANSFER_DMA_MAP
- *      is set).  This buffer must be suitable for DMA; allocate it with
+ * @transfer_buffer:  This identifies the buffer to (or from) which the I/O
+ *      request will be performed unless URB_NO_TRANSFER_DMA_MAP is set
+ *      (however, do not leave garbage in transfer_buffer even then).
+ *      This buffer must be suitable for DMA; allocate it with
  *      kmalloc() or equivalent.  For transfers to "in" endpoints, contents
  *      of this buffer will be modified.  This buffer is used for the data
  *      stage of control transfers.
@@ -1104,9 +1105,15 @@ typedef void (*usb_complete_t)(struct urb *);
  * allocate a DMA buffer with usb_buffer_alloc() or call usb_buffer_map().
  * When these transfer flags are provided, host controller drivers will
  * attempt to use the dma addresses found in the transfer_dma and/or
- * setup_dma fields rather than determining a dma address themselves.  (Note
- * that transfer_buffer and setup_packet must still be set because not all
- * host controllers use DMA, nor do virtual root hubs).
+ * setup_dma fields rather than determining a dma address themselves.
+ *
+ * Note that transfer_buffer must still be set if the controller
+ * does not support DMA (as indicated by bus.uses_dma) and when talking
+ * to root hub. If you have to trasfer between highmem zone and the device
+ * on such controller, create a bounce buffer or bail out with an error.
+ * If transfer_buffer cannot be set (is in highmem) and the controller is DMA
+ * capable, assign NULL to it, so that usbmon knows not to use the value.
+ * The setup_packet must always be set, so it cannot be located in highmem.
  *
  * Initialization:
  *
diff --git a/include/linux/usb/audio.h b/include/linux/usb/audio.h
index b5744bc218ab..eaf9dffe0a01 100644
--- a/include/linux/usb/audio.h
+++ b/include/linux/usb/audio.h
@@ -24,88 +24,78 @@
 #define USB_SUBCLASS_AUDIOCONTROL       0x01
 #define USB_SUBCLASS_AUDIOSTREAMING     0x02
 #define USB_SUBCLASS_MIDISTREAMING      0x03
-#define USB_SUBCLASS_VENDOR_SPEC        0xff
-
-/* A.5 Audio Class-Specific AC interface Descriptor Subtypes*/
-#define HEADER                          0x01
-#define INPUT_TERMINAL                  0x02
-#define OUTPUT_TERMINAL                 0x03
-#define MIXER_UNIT                      0x04
-#define SELECTOR_UNIT                   0x05
-#define FEATURE_UNIT                    0x06
-#define PROCESSING_UNIT                 0x07
-#define EXTENSION_UNIT                  0x08
-
-#define AS_GENERAL                      0x01
-#define FORMAT_TYPE                     0x02
-#define FORMAT_SPECIFIC                 0x03
-
-#define EP_GENERAL                      0x01
-
-#define MS_GENERAL                      0x01
-#define MIDI_IN_JACK                    0x02
-#define MIDI_OUT_JACK                   0x03
-
-/* endpoint attributes */
-#define EP_ATTR_MASK                    0x0c
-#define EP_ATTR_ASYNC                   0x04
-#define EP_ATTR_ADAPTIVE                0x08
-#define EP_ATTR_SYNC                    0x0c
-
-/* cs endpoint attributes */
-#define EP_CS_ATTR_SAMPLE_RATE          0x01
-#define EP_CS_ATTR_PITCH_CONTROL        0x02
-#define EP_CS_ATTR_FILL_MAX             0x80
-
-/* Audio Class specific Request Codes */
-#define USB_AUDIO_SET_INTF              0x21
-#define USB_AUDIO_SET_ENDPOINT          0x22
-#define USB_AUDIO_GET_INTF              0xa1
-#define USB_AUDIO_GET_ENDPOINT          0xa2
-
-#define SET_    0x00
-#define GET_    0x80
-
-#define _CUR    0x1
-#define _MIN    0x2
-#define _MAX    0x3
-#define _RES    0x4
-#define _MEM    0x5
-
-#define SET_CUR         (SET_ | _CUR)
-#define GET_CUR         (GET_ | _CUR)
-#define SET_MIN         (SET_ | _MIN)
-#define GET_MIN         (GET_ | _MIN)
-#define SET_MAX         (SET_ | _MAX)
-#define GET_MAX         (GET_ | _MAX)
-#define SET_RES         (SET_ | _RES)
-#define GET_RES         (GET_ | _RES)
-#define SET_MEM         (SET_ | _MEM)
-#define GET_MEM         (GET_ | _MEM)
-
-#define GET_STAT        0xff
-
-#define USB_AC_TERMINAL_UNDEFINED       0x100
-#define USB_AC_TERMINAL_STREAMING       0x101
-#define USB_AC_TERMINAL_VENDOR_SPEC     0x1FF
+
+/* A.5 Audio Class-Specific AC Interface Descriptor Subtypes */
+#define UAC_HEADER                      0x01
+#define UAC_INPUT_TERMINAL              0x02
+#define UAC_OUTPUT_TERMINAL             0x03
+#define UAC_MIXER_UNIT                  0x04
+#define UAC_SELECTOR_UNIT               0x05
+#define UAC_FEATURE_UNIT                0x06
+#define UAC_PROCESSING_UNIT             0x07
+#define UAC_EXTENSION_UNIT              0x08
+
+/* A.6 Audio Class-Specific AS Interface Descriptor Subtypes */
+#define UAC_AS_GENERAL                  0x01
+#define UAC_FORMAT_TYPE                 0x02
+#define UAC_FORMAT_SPECIFIC             0x03
+
+/* A.8 Audio Class-Specific Endpoint Descriptor Subtypes */
+#define UAC_EP_GENERAL                  0x01
+
+/* A.9 Audio Class-Specific Request Codes */
+#define UAC_SET_                        0x00
+#define UAC_GET_                        0x80
+
+#define UAC__CUR                        0x1
+#define UAC__MIN                        0x2
+#define UAC__MAX                        0x3
+#define UAC__RES                        0x4
+#define UAC__MEM                        0x5
+
+#define UAC_SET_CUR                     (UAC_SET_ | UAC__CUR)
+#define UAC_GET_CUR                     (UAC_GET_ | UAC__CUR)
+#define UAC_SET_MIN                     (UAC_SET_ | UAC__MIN)
+#define UAC_GET_MIN                     (UAC_GET_ | UAC__MIN)
+#define UAC_SET_MAX                     (UAC_SET_ | UAC__MAX)
+#define UAC_GET_MAX                     (UAC_GET_ | UAC__MAX)
+#define UAC_SET_RES                     (UAC_SET_ | UAC__RES)
+#define UAC_GET_RES                     (UAC_GET_ | UAC__RES)
+#define UAC_SET_MEM                     (UAC_SET_ | UAC__MEM)
+#define UAC_GET_MEM                     (UAC_GET_ | UAC__MEM)
+
+#define UAC_GET_STAT                    0xff
+
+/* MIDI - A.1 MS Class-Specific Interface Descriptor Subtypes */
+#define UAC_MS_HEADER                   0x01
+#define UAC_MIDI_IN_JACK                0x02
+#define UAC_MIDI_OUT_JACK               0x03
+
+/* MIDI - A.1 MS Class-Specific Endpoint Descriptor Subtypes */
+#define UAC_MS_GENERAL                  0x01
+
+/* Terminals - 2.1 USB Terminal Types */
+#define UAC_TERMINAL_UNDEFINED          0x100
+#define UAC_TERMINAL_STREAMING          0x101
+#define UAC_TERMINAL_VENDOR_SPEC        0x1FF
 
 /* Terminal Control Selectors */
 /* 4.3.2  Class-Specific AC Interface Descriptor */
-struct usb_ac_header_descriptor {
+struct uac_ac_header_descriptor {
         __u8  bLength;                  /* 8 + n */
         __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
-        __u8  bDescriptorSubtype;       /* USB_MS_HEADER */
+        __u8  bDescriptorSubtype;       /* UAC_MS_HEADER */
         __le16 bcdADC;                  /* 0x0100 */
         __le16 wTotalLength;            /* includes Unit and Terminal desc. */
         __u8  bInCollection;            /* n */
         __u8  baInterfaceNr[];          /* [n] */
 } __attribute__ ((packed));
 
-#define USB_DT_AC_HEADER_SIZE(n)        (8 + (n))
+#define UAC_DT_AC_HEADER_SIZE(n)        (8 + (n))
 
 /* As above, but more useful for defining your own descriptors: */
-#define DECLARE_USB_AC_HEADER_DESCRIPTOR(n)                     \
-struct usb_ac_header_descriptor_##n {                           \
+#define DECLARE_UAC_AC_HEADER_DESCRIPTOR(n)                     \
+struct uac_ac_header_descriptor_##n {                           \
         __u8  bLength;                                          \
         __u8  bDescriptorType;                                  \
         __u8  bDescriptorSubtype;                               \
@@ -116,7 +106,7 @@ struct usb_ac_header_descriptor_##n {				\
 } __attribute__ ((packed))
 
 /* 4.3.2.1 Input Terminal Descriptor */
-struct usb_input_terminal_descriptor {
+struct uac_input_terminal_descriptor {
         __u8  bLength;                  /* in bytes: 12 */
         __u8  bDescriptorType;          /* CS_INTERFACE descriptor type */
         __u8  bDescriptorSubtype;       /* INPUT_TERMINAL descriptor subtype */
@@ -129,18 +119,19 @@ struct usb_input_terminal_descriptor {
         __u8  iTerminal;
 } __attribute__ ((packed));
 
-#define USB_DT_AC_INPUT_TERMINAL_SIZE                   12
+#define UAC_DT_INPUT_TERMINAL_SIZE                      12
 
-#define USB_AC_INPUT_TERMINAL_UNDEFINED                 0x200
-#define USB_AC_INPUT_TERMINAL_MICROPHONE                0x201
-#define USB_AC_INPUT_TERMINAL_DESKTOP_MICROPHONE        0x202
-#define USB_AC_INPUT_TERMINAL_PERSONAL_MICROPHONE       0x203
-#define USB_AC_INPUT_TERMINAL_OMNI_DIR_MICROPHONE       0x204
-#define USB_AC_INPUT_TERMINAL_MICROPHONE_ARRAY          0x205
-#define USB_AC_INPUT_TERMINAL_PROC_MICROPHONE_ARRAY     0x206
+/* Terminals - 2.2 Input Terminal Types */
+#define UAC_INPUT_TERMINAL_UNDEFINED                    0x200
+#define UAC_INPUT_TERMINAL_MICROPHONE                   0x201
+#define UAC_INPUT_TERMINAL_DESKTOP_MICROPHONE           0x202
+#define UAC_INPUT_TERMINAL_PERSONAL_MICROPHONE          0x203
+#define UAC_INPUT_TERMINAL_OMNI_DIR_MICROPHONE          0x204
+#define UAC_INPUT_TERMINAL_MICROPHONE_ARRAY             0x205
+#define UAC_INPUT_TERMINAL_PROC_MICROPHONE_ARRAY        0x206
 
 /* 4.3.2.2 Output Terminal Descriptor */
-struct usb_output_terminal_descriptor {
+struct uac_output_terminal_descriptor {
         __u8  bLength;                  /* in bytes: 9 */
         __u8  bDescriptorType;          /* CS_INTERFACE descriptor type */
         __u8  bDescriptorSubtype;       /* OUTPUT_TERMINAL descriptor subtype */
@@ -151,23 +142,24 @@ struct usb_output_terminal_descriptor {
         __u8  iTerminal;
 } __attribute__ ((packed));
 
-#define USB_DT_AC_OUTPUT_TERMINAL_SIZE                          9
+#define UAC_DT_OUTPUT_TERMINAL_SIZE                     9
 
-#define USB_AC_OUTPUT_TERMINAL_UNDEFINED                        0x300
-#define USB_AC_OUTPUT_TERMINAL_SPEAKER                          0x301
-#define USB_AC_OUTPUT_TERMINAL_HEADPHONES                       0x302
-#define USB_AC_OUTPUT_TERMINAL_HEAD_MOUNTED_DISPLAY_AUDIO       0x303
-#define USB_AC_OUTPUT_TERMINAL_DESKTOP_SPEAKER                  0x304
-#define USB_AC_OUTPUT_TERMINAL_ROOM_SPEAKER                     0x305
-#define USB_AC_OUTPUT_TERMINAL_COMMUNICATION_SPEAKER            0x306
-#define USB_AC_OUTPUT_TERMINAL_LOW_FREQ_EFFECTS_SPEAKER         0x307
+/* Terminals - 2.3 Output Terminal Types */
+#define UAC_OUTPUT_TERMINAL_UNDEFINED                   0x300
+#define UAC_OUTPUT_TERMINAL_SPEAKER                     0x301
+#define UAC_OUTPUT_TERMINAL_HEADPHONES                  0x302
+#define UAC_OUTPUT_TERMINAL_HEAD_MOUNTED_DISPLAY_AUDIO  0x303
+#define UAC_OUTPUT_TERMINAL_DESKTOP_SPEAKER             0x304
+#define UAC_OUTPUT_TERMINAL_ROOM_SPEAKER                0x305
+#define UAC_OUTPUT_TERMINAL_COMMUNICATION_SPEAKER       0x306
+#define UAC_OUTPUT_TERMINAL_LOW_FREQ_EFFECTS_SPEAKER    0x307
 
 /* Set bControlSize = 2 as default setting */
-#define USB_DT_AC_FEATURE_UNIT_SIZE(ch)         (7 + ((ch) + 1) * 2)
+#define UAC_DT_FEATURE_UNIT_SIZE(ch)            (7 + ((ch) + 1) * 2)
 
 /* As above, but more useful for defining your own descriptors: */
-#define DECLARE_USB_AC_FEATURE_UNIT_DESCRIPTOR(ch)              \
-struct usb_ac_feature_unit_descriptor_##ch {                    \
+#define DECLARE_UAC_FEATURE_UNIT_DESCRIPTOR(ch)                 \
+struct uac_feature_unit_descriptor_##ch {                       \
         __u8  bLength;                                          \
         __u8  bDescriptorType;                                  \
         __u8  bDescriptorSubtype;                               \
@@ -179,7 +171,7 @@ struct usb_ac_feature_unit_descriptor_##ch {			\
 } __attribute__ ((packed))
 
 /* 4.5.2 Class-Specific AS Interface Descriptor */
-struct usb_as_header_descriptor {
+struct uac_as_header_descriptor {
         __u8  bLength;                  /* in bytes: 7 */
         __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
         __u8  bDescriptorSubtype;       /* AS_GENERAL */
@@ -188,16 +180,17 @@ struct usb_as_header_descriptor {
         __le16 wFormatTag;              /* The Audio Data Format */
 } __attribute__ ((packed));
 
-#define USB_DT_AS_HEADER_SIZE           7
+#define UAC_DT_AS_HEADER_SIZE           7
 
-#define USB_AS_AUDIO_FORMAT_TYPE_I_UNDEFINED    0x0
-#define USB_AS_AUDIO_FORMAT_TYPE_I_PCM          0x1
-#define USB_AS_AUDIO_FORMAT_TYPE_I_PCM8         0x2
-#define USB_AS_AUDIO_FORMAT_TYPE_I_IEEE_FLOAT   0x3
-#define USB_AS_AUDIO_FORMAT_TYPE_I_ALAW         0x4
-#define USB_AS_AUDIO_FORMAT_TYPE_I_MULAW        0x5
+/* Formats - A.1.1 Audio Data Format Type I Codes */
+#define UAC_FORMAT_TYPE_I_UNDEFINED     0x0
+#define UAC_FORMAT_TYPE_I_PCM           0x1
+#define UAC_FORMAT_TYPE_I_PCM8          0x2
+#define UAC_FORMAT_TYPE_I_IEEE_FLOAT    0x3
+#define UAC_FORMAT_TYPE_I_ALAW          0x4
+#define UAC_FORMAT_TYPE_I_MULAW         0x5
 
-struct usb_as_format_type_i_continuous_descriptor {
+struct uac_format_type_i_continuous_descriptor {
         __u8  bLength;                  /* in bytes: 8 + (ns * 3) */
         __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
         __u8  bDescriptorSubtype;       /* FORMAT_TYPE */
@@ -210,9 +203,9 @@ struct usb_as_format_type_i_continuous_descriptor {
         __u8  tUpperSamFreq[3];
 } __attribute__ ((packed));
 
-#define USB_AS_FORMAT_TYPE_I_CONTINUOUS_DESC_SIZE       14
+#define UAC_FORMAT_TYPE_I_CONTINUOUS_DESC_SIZE  14
 
-struct usb_as_formate_type_i_discrete_descriptor {
+struct uac_format_type_i_discrete_descriptor {
         __u8  bLength;                  /* in bytes: 8 + (ns * 3) */
         __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
         __u8  bDescriptorSubtype;       /* FORMAT_TYPE */
@@ -224,8 +217,8 @@ struct usb_as_formate_type_i_discrete_descriptor {
         __u8  tSamFreq[][3];
 } __attribute__ ((packed));
 
-#define DECLARE_USB_AS_FORMAT_TYPE_I_DISCRETE_DESC(n)           \
-struct usb_as_formate_type_i_discrete_descriptor_##n {          \
+#define DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(n)              \
+struct uac_format_type_i_discrete_descriptor_##n {              \
         __u8  bLength;                                          \
         __u8  bDescriptorType;                                  \
         __u8  bDescriptorSubtype;                               \
@@ -237,18 +230,15 @@ struct usb_as_formate_type_i_discrete_descriptor_##n {		\
         __u8  tSamFreq[n][3];                                   \
 } __attribute__ ((packed))
 
-#define USB_AS_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(n)      (8 + (n * 3))
-
-#define USB_AS_FORMAT_TYPE_UNDEFINED    0x0
-#define USB_AS_FORMAT_TYPE_I            0x1
-#define USB_AS_FORMAT_TYPE_II           0x2
-#define USB_AS_FORMAT_TYPE_III          0x3
+#define UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(n) (8 + (n * 3))
 
-#define USB_AS_ENDPOINT_ASYNC           (1 << 2)
-#define USB_AS_ENDPOINT_ADAPTIVE        (2 << 2)
-#define USB_AS_ENDPOINT_SYNC            (3 << 2)
+/* Formats - A.2 Format Type Codes */
+#define UAC_FORMAT_TYPE_UNDEFINED       0x0
+#define UAC_FORMAT_TYPE_I               0x1
+#define UAC_FORMAT_TYPE_II              0x2
+#define UAC_FORMAT_TYPE_III             0x3
 
-struct usb_as_iso_endpoint_descriptor {
+struct uac_iso_endpoint_descriptor {
         __u8  bLength;                  /* in bytes: 7 */
         __u8  bDescriptorType;          /* USB_DT_CS_ENDPOINT */
         __u8  bDescriptorSubtype;       /* EP_GENERAL */
@@ -256,30 +246,37 @@ struct usb_as_iso_endpoint_descriptor {
         __u8  bLockDelayUnits;
         __le16 wLockDelay;
 };
-#define USB_AS_ISO_ENDPOINT_DESC_SIZE   7
-
-#define FU_CONTROL_UNDEFINED            0x00
-#define MUTE_CONTROL                    0x01
-#define VOLUME_CONTROL                  0x02
-#define BASS_CONTROL                    0x03
-#define MID_CONTROL                     0x04
-#define TREBLE_CONTROL                  0x05
-#define GRAPHIC_EQUALIZER_CONTROL       0x06
-#define AUTOMATIC_GAIN_CONTROL          0x07
-#define DELAY_CONTROL                   0x08
-#define BASS_BOOST_CONTROL              0x09
-#define LOUDNESS_CONTROL                0x0a
-
-#define FU_MUTE         (1 << (MUTE_CONTROL - 1))
-#define FU_VOLUME       (1 << (VOLUME_CONTROL - 1))
-#define FU_BASS         (1 << (BASS_CONTROL - 1))
-#define FU_MID          (1 << (MID_CONTROL - 1))
-#define FU_TREBLE       (1 << (TREBLE_CONTROL - 1))
-#define FU_GRAPHIC_EQ   (1 << (GRAPHIC_EQUALIZER_CONTROL - 1))
-#define FU_AUTO_GAIN    (1 << (AUTOMATIC_GAIN_CONTROL - 1))
-#define FU_DELAY        (1 << (DELAY_CONTROL - 1))
-#define FU_BASS_BOOST   (1 << (BASS_BOOST_CONTROL - 1))
-#define FU_LOUDNESS     (1 << (LOUDNESS_CONTROL - 1))
+#define UAC_ISO_ENDPOINT_DESC_SIZE      7
+
+#define UAC_EP_CS_ATTR_SAMPLE_RATE      0x01
+#define UAC_EP_CS_ATTR_PITCH_CONTROL    0x02
+#define UAC_EP_CS_ATTR_FILL_MAX         0x80
+
+/* A.10.2 Feature Unit Control Selectors */
+#define UAC_FU_CONTROL_UNDEFINED        0x00
+#define UAC_MUTE_CONTROL                0x01
+#define UAC_VOLUME_CONTROL              0x02
+#define UAC_BASS_CONTROL                0x03
+#define UAC_MID_CONTROL                 0x04
+#define UAC_TREBLE_CONTROL              0x05
+#define UAC_GRAPHIC_EQUALIZER_CONTROL   0x06
+#define UAC_AUTOMATIC_GAIN_CONTROL      0x07
+#define UAC_DELAY_CONTROL               0x08
+#define UAC_BASS_BOOST_CONTROL          0x09
+#define UAC_LOUDNESS_CONTROL            0x0a
+
+#define UAC_FU_MUTE             (1 << (UAC_MUTE_CONTROL - 1))
+#define UAC_FU_VOLUME           (1 << (UAC_VOLUME_CONTROL - 1))
+#define UAC_FU_BASS             (1 << (UAC_BASS_CONTROL - 1))
+#define UAC_FU_MID              (1 << (UAC_MID_CONTROL - 1))
+#define UAC_FU_TREBLE           (1 << (UAC_TREBLE_CONTROL - 1))
+#define UAC_FU_GRAPHIC_EQ       (1 << (UAC_GRAPHIC_EQUALIZER_CONTROL - 1))
+#define UAC_FU_AUTO_GAIN        (1 << (UAC_AUTOMATIC_GAIN_CONTROL - 1))
+#define UAC_FU_DELAY            (1 << (UAC_DELAY_CONTROL - 1))
+#define UAC_FU_BASS_BOOST       (1 << (UAC_BASS_BOOST_CONTROL - 1))
+#define UAC_FU_LOUDNESS         (1 << (UAC_LOUDNESS_CONTROL - 1))
+
+#ifdef __KERNEL__
 
 struct usb_audio_control {
         struct list_head list;
@@ -290,18 +287,6 @@ struct usb_audio_control {
         int (*get)(struct usb_audio_control *con, u8 cmd);
 };
 
-static inline int generic_set_cmd(struct usb_audio_control *con, u8 cmd, int value)
-{
-        con->data[cmd] = value;
-
-        return 0;
-}
-
-static inline int generic_get_cmd(struct usb_audio_control *con, u8 cmd)
-{
-        return con->data[cmd];
-}
-
 struct usb_audio_control_selector {
         struct list_head list;
         struct list_head control;
@@ -311,4 +296,6 @@ struct usb_audio_control_selector {
         struct usb_descriptor_header *desc;
 };
 
+#endif /* __KERNEL__ */
+
 #endif /* __LINUX_USB_AUDIO_H */
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index 93223638f702..94012e649d86 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -258,6 +258,8 @@ struct usb_device_descriptor {
 #define USB_CLASS_APP_SPEC              0xfe
 #define USB_CLASS_VENDOR_SPEC           0xff
 
+#define USB_SUBCLASS_VENDOR_SPEC        0xff
+
 /*-------------------------------------------------------------------------*/
 
 /* USB_DT_CONFIG: Configuration descriptor information.
@@ -348,6 +350,12 @@ struct usb_endpoint_descriptor {
 #define USB_ENDPOINT_NUMBER_MASK        0x0f    /* in bEndpointAddress */
 #define USB_ENDPOINT_DIR_MASK           0x80
 
+#define USB_ENDPOINT_SYNCTYPE           0x0c
+#define USB_ENDPOINT_SYNC_NONE          (0 << 2)
+#define USB_ENDPOINT_SYNC_ASYNC         (1 << 2)
+#define USB_ENDPOINT_SYNC_ADAPTIVE      (2 << 2)
+#define USB_ENDPOINT_SYNC_SYNC          (3 << 2)
+
 #define USB_ENDPOINT_XFERTYPE_MASK      0x03    /* in bmAttributes */
 #define USB_ENDPOINT_XFER_CONTROL       0
 #define USB_ENDPOINT_XFER_ISOC          1
diff --git a/include/linux/usb/ehci_def.h b/include/linux/usb/ehci_def.h
index 5b88e36c9103..af4b86f3aca3 100644
--- a/include/linux/usb/ehci_def.h
+++ b/include/linux/usb/ehci_def.h
@@ -105,6 +105,7 @@ struct ehci_regs {
 #define PORT_WKDISC_E   (1<<21)         /* wake on disconnect (enable) */
 #define PORT_WKCONN_E   (1<<20)         /* wake on connect (enable) */
 /* 19:16 for port testing */
+#define PORT_TEST_PKT   (0x4<<16)       /* Port Test Control - packet test */
 #define PORT_LED_OFF    (0<<14)
 #define PORT_LED_AMBER  (1<<14)
 #define PORT_LED_GREEN  (2<<14)
@@ -132,6 +133,19 @@ struct ehci_regs {
 #define USBMODE_CM_HC   (3<<0)          /* host controller mode */
 #define USBMODE_CM_IDLE (0<<0)          /* idle state */
 
+/* Moorestown has some non-standard registers, partially due to the fact that
+ * its EHCI controller has both TT and LPM support. HOSTPCx are extentions to
+ * PORTSCx
+ */
+#define HOSTPC0         0x84            /* HOSTPC extension */
+#define HOSTPC_PHCD     (1<<22)         /* Phy clock disable */
+#define HOSTPC_PSPD     (3<<25)         /* Port speed detection */
+#define USBMODE_EX      0xc8            /* USB Device mode extension */
+#define USBMODE_EX_VBPS (1<<5)          /* VBus Power Select On */
+#define USBMODE_EX_HC   (3<<0)          /* host controller mode */
+#define TXFILLTUNING    0x24            /* TX FIFO Tuning register */
+#define TXFIFO_DEFAULT  (8<<16)         /* FIFO burst threshold 8 */
+
 /* Appendix C, Debug port ... intended for use with special "debug devices"
  * that can help if there's no serial console.  (nonstandard enumeration.)
  */
@@ -157,4 +171,25 @@ struct ehci_dbg_port {
 #define DBGP_EPADDR(dev, ep)    (((dev)<<8)|(ep))
 } __attribute__ ((packed));
 
+#ifdef CONFIG_EARLY_PRINTK_DBGP
+#include <linux/init.h>
+extern int __init early_dbgp_init(char *s);
+extern struct console early_dbgp_console;
+#endif /* CONFIG_EARLY_PRINTK_DBGP */
+
+#ifdef CONFIG_EARLY_PRINTK_DBGP
+/* Call backs from ehci host driver to ehci debug driver */
+extern int dbgp_external_startup(void);
+extern int dbgp_reset_prep(void);
+#else
+static inline int dbgp_reset_prep(void)
+{
+        return 1;
+}
+static inline int dbgp_external_startup(void)
+{
+        return -1;
+}
+#endif
+
 #endif /* __LINUX_USB_EHCI_DEF_H */
diff --git a/include/linux/usb/isp1362.h b/include/linux/usb/isp1362.h
new file mode 100644
index 000000000000..642684bb9292
--- /dev/null
+++ b/include/linux/usb/isp1362.h
@@ -0,0 +1,46 @@
+/*
+ * board initialization code should put one of these into dev->platform_data
+ * and place the isp1362 onto platform_bus.
+ */
+
+#ifndef __LINUX_USB_ISP1362_H__
+#define __LINUX_USB_ISP1362_H__
+
+struct isp1362_platform_data {
+        /* Enable internal pulldown resistors on downstream ports */
+        unsigned sel15Kres:1;
+        /* Clock cannot be stopped */
+        unsigned clknotstop:1;
+        /* On-chip overcurrent protection */
+        unsigned oc_enable:1;
+        /* INT output polarity */
+        unsigned int_act_high:1;
+        /* INT edge or level triggered */
+        unsigned int_edge_triggered:1;
+        /* DREQ output polarity */
+        unsigned dreq_act_high:1;
+        /* DACK input polarity */
+        unsigned dack_act_high:1;
+        /* chip can be resumed via H_WAKEUP pin */
+        unsigned remote_wakeup_connected:1;
+        /* Switch or not to switch (keep always powered) */
+        unsigned no_power_switching:1;
+        /* Ganged port power switching (0) or individual port power switching (1) */
+        unsigned power_switching_mode:1;
+        /* Given port_power, msec/2 after power on till power good */
+        u8 potpg;
+        /* Hardware reset set/clear */
+        void (*reset) (struct device *dev, int set);
+        /* Clock start/stop */
+        void (*clock) (struct device *dev, int start);
+        /* Inter-io delay (ns). The chip is picky about access timings; it
+         * expects at least:
+         * 110ns delay between consecutive accesses to DATA_REG,
+         * 300ns delay between access to ADDR_REG and DATA_REG (registers)
+         * 462ns delay between access to ADDR_REG and DATA_REG (buffer memory)
+         * WE MUST NOT be activated during these intervals (even without CS!)
+         */
+        void (*delay) (struct device *dev, unsigned int delay);
+};
+
+#endif
diff --git a/include/linux/usb/isp1760.h b/include/linux/usb/isp1760.h
new file mode 100644
index 000000000000..de7de53c5531
--- /dev/null
+++ b/include/linux/usb/isp1760.h
@@ -0,0 +1,18 @@
+/*
+ * board initialization should put one of these into dev->platform_data
+ * and place the isp1760 onto platform_bus named "isp1760-hcd".
+ */
+
+#ifndef __LINUX_USB_ISP1760_H
+#define __LINUX_USB_ISP1760_H
+
+struct isp1760_platform_data {
+        unsigned is_isp1761:1;                  /* Chip is ISP1761 */
+        unsigned bus_width_16:1;                /* 16/32-bit data bus width */
+        unsigned port1_otg:1;                   /* Port 1 supports OTG */
+        unsigned analog_oc:1;                   /* Analog overcurrent */
+        unsigned dack_polarity_high:1;          /* DACK active high */
+        unsigned dreq_polarity_high:1;          /* DREQ active high */
+};
+
+#endif /* __LINUX_USB_ISP1760_H */
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 7b85e327af91..c17eb64d7213 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -59,6 +59,7 @@ enum port_dev_state {
  * @bulk_out_buffer: pointer to the bulk out buffer for this port.
  * @bulk_out_size: the size of the bulk_out_buffer, in bytes.
  * @write_urb: pointer to the bulk out struct urb for this port.
+ * @write_fifo: kfifo used to buffer outgoing data
  * @write_urb_busy: port`s writing status
  * @bulk_out_endpointAddress: endpoint address for the bulk out pipe for this
  *      port.
@@ -96,6 +97,7 @@ struct usb_serial_port {
         unsigned char           *bulk_out_buffer;
         int                     bulk_out_size;
         struct urb              *write_urb;
+        struct kfifo            *write_fifo;
         int                     write_urb_busy;
         __u8                    bulk_out_endpointAddress;
 
diff --git a/include/linux/usbdevice_fs.h b/include/linux/usbdevice_fs.h
index 0044d9b4cb85..b2a7d8ba6ee3 100644
--- a/include/linux/usbdevice_fs.h
+++ b/include/linux/usbdevice_fs.h
@@ -77,6 +77,7 @@ struct usbdevfs_connectinfo {
 
 #define USBDEVFS_URB_SHORT_NOT_OK       0x01
 #define USBDEVFS_URB_ISO_ASAP           0x02
+#define USBDEVFS_URB_BULK_CONTINUATION  0x04
 #define USBDEVFS_URB_NO_FSBR            0x20
 #define USBDEVFS_URB_ZERO_PACKET        0x40
 #define USBDEVFS_URB_NO_INTERRUPT       0x80
@@ -175,4 +176,6 @@ struct usbdevfs_ioctl32 {
 #define USBDEVFS_CLEAR_HALT        _IOR('U', 21, unsigned int)
 #define USBDEVFS_DISCONNECT        _IO('U', 22)
 #define USBDEVFS_CONNECT           _IO('U', 23)
+#define USBDEVFS_CLAIM_PORT        _IOR('U', 24, unsigned int)
+#define USBDEVFS_RELEASE_PORT      _IOR('U', 25, unsigned int)
 #endif /* _LINUX_USBDEVICE_FS_H */