105 files changed, 11475 insertions, 1209 deletions

diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index 516a6400db43..a419c42e880e 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -17,6 +17,8 @@ obj-$(CONFIG_USB_SL811_HCD)	+= host/
 obj-$(CONFIG_USB_U132_HCD)      += host/
 obj-$(CONFIG_USB_R8A66597_HCD)  += host/
 
+obj-$(CONFIG_USB_C67X00_HCD)    += c67x00/
+
 obj-$(CONFIG_USB_ACM)           += class/
 obj-$(CONFIG_USB_PRINTER)       += class/
 
diff --git a/drivers/usb/atm/Kconfig b/drivers/usb/atm/Kconfig
index 86e64035edb0..be0b8daac9c7 100644
--- a/drivers/usb/atm/Kconfig
+++ b/drivers/usb/atm/Kconfig
@@ -19,7 +19,6 @@ if USB_ATM
 
 config USB_SPEEDTOUCH
         tristate "Speedtouch USB support"
-        depends on USB_ATM
         select FW_LOADER
         help
           Say Y here if you have an SpeedTouch USB or SpeedTouch 330
@@ -32,7 +31,6 @@ config USB_SPEEDTOUCH
 
 config USB_CXACRU
         tristate "Conexant AccessRunner USB support"
-        depends on USB_ATM
         select FW_LOADER
         help
           Say Y here if you have an ADSL USB modem based on the Conexant
@@ -45,7 +43,6 @@ config USB_CXACRU
 
 config USB_UEAGLEATM
         tristate "ADI 930 and eagle USB DSL modem"
-        depends on USB_ATM
         select FW_LOADER
         help
           Say Y here if you have an ADSL USB modem based on the ADI 930
@@ -58,7 +55,6 @@ config USB_UEAGLEATM
 
 config USB_XUSBATM
         tristate "Other USB DSL modem support"
-        depends on USB_ATM
         help
           Say Y here if you have a DSL USB modem not explicitly supported by
           another USB DSL drivers.  In order to use your modem you will need to
diff --git a/drivers/usb/c67x00/Makefile b/drivers/usb/c67x00/Makefile
new file mode 100644
index 000000000000..868bc41b5980
--- /dev/null
+++ b/drivers/usb/c67x00/Makefile
@@ -0,0 +1,9 @@
+#
+# Makefile for Cypress C67X00 USB Controller
+#
+
+ccflags-$(CONFIG_USB_DEBUG)             += -DDEBUG
+
+obj-$(CONFIG_USB_C67X00_HCD)            += c67x00.o
+
+c67x00-objs := c67x00-drv.o c67x00-ll-hpi.o c67x00-hcd.o c67x00-sched.o
diff --git a/drivers/usb/c67x00/c67x00-drv.c b/drivers/usb/c67x00/c67x00-drv.c
new file mode 100644
index 000000000000..5633bc5c8bf2
--- /dev/null
+++ b/drivers/usb/c67x00/c67x00-drv.c
@@ -0,0 +1,243 @@
+/*
+ * c67x00-drv.c: Cypress C67X00 USB Common infrastructure
+ *
+ * Copyright (C) 2006-2008 Barco N.V.
+ *    Derived from the Cypress cy7c67200/300 ezusb linux driver and
+ *    based on multiple host controller drivers inside the linux kernel.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA.
+ */
+
+/*
+ * This file implements the common infrastructure for using the c67x00.
+ * It is both the link between the platform configuration and subdrivers and
+ * the link between the common hardware parts and the subdrivers (e.g.
+ * interrupt handling).
+ *
+ * The c67x00 has 2 SIE's (serial interface engine) wich can be configured
+ * to be host, device or OTG (with some limitations, E.G. only SIE1 can be OTG).
+ *
+ * Depending on the platform configuration, the SIE's are created and
+ * the corresponding subdriver is initialized (c67x00_probe_sie).
+ */
+
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/list.h>
+#include <linux/usb.h>
+#include <linux/usb/c67x00.h>
+
+#include "c67x00.h"
+#include "c67x00-hcd.h"
+
+static void c67x00_probe_sie(struct c67x00_sie *sie,
+                             struct c67x00_device *dev, int sie_num)
+{
+        spin_lock_init(&sie->lock);
+        sie->dev = dev;
+        sie->sie_num = sie_num;
+        sie->mode = c67x00_sie_config(dev->pdata->sie_config, sie_num);
+
+        switch (sie->mode) {
+        case C67X00_SIE_HOST:
+                c67x00_hcd_probe(sie);
+                break;
+
+        case C67X00_SIE_UNUSED:
+                dev_info(sie_dev(sie),
+                         "Not using SIE %d as requested\n", sie->sie_num);
+                break;
+
+        default:
+                dev_err(sie_dev(sie),
+                        "Unsupported configuration: 0x%x for SIE %d\n",
+                        sie->mode, sie->sie_num);
+                break;
+        }
+}
+
+static void c67x00_remove_sie(struct c67x00_sie *sie)
+{
+        switch (sie->mode) {
+        case C67X00_SIE_HOST:
+                c67x00_hcd_remove(sie);
+                break;
+
+        default:
+                break;
+        }
+}
+
+static irqreturn_t c67x00_irq(int irq, void *__dev)
+{
+        struct c67x00_device *c67x00 = __dev;
+        struct c67x00_sie *sie;
+        u16 msg, int_status;
+        int i, count = 8;
+
+        int_status = c67x00_ll_hpi_status(c67x00);
+        if (!int_status)
+                return IRQ_NONE;
+
+        while (int_status != 0 && (count-- >= 0)) {
+                c67x00_ll_irq(c67x00, int_status);
+                for (i = 0; i < C67X00_SIES; i++) {
+                        sie = &c67x00->sie[i];
+                        msg = 0;
+                        if (int_status & SIEMSG_FLG(i))
+                                msg = c67x00_ll_fetch_siemsg(c67x00, i);
+                        if (sie->irq)
+                                sie->irq(sie, int_status, msg);
+                }
+                int_status = c67x00_ll_hpi_status(c67x00);
+        }
+
+        if (int_status)
+                dev_warn(&c67x00->pdev->dev, "Not all interrupts handled! "
+                         "status = 0x%04x\n", int_status);
+
+        return IRQ_HANDLED;
+}
+
+/* ------------------------------------------------------------------------- */
+
+static int __devinit c67x00_drv_probe(struct platform_device *pdev)
+{
+        struct c67x00_device *c67x00;
+        struct c67x00_platform_data *pdata;
+        struct resource *res, *res2;
+        int ret, i;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        res2 = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res2)
+                return -ENODEV;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata)
+                return -ENODEV;
+
+        c67x00 = kzalloc(sizeof(*c67x00), GFP_KERNEL);
+        if (!c67x00)
+                return -ENOMEM;
+
+        if (!request_mem_region(res->start, res->end - res->start + 1,
+                                pdev->name)) {
+                dev_err(&pdev->dev, "Memory region busy\n");
+                ret = -EBUSY;
+                goto request_mem_failed;
+        }
+        c67x00->hpi.base = ioremap(res->start, res->end - res->start + 1);
+        if (!c67x00->hpi.base) {
+                dev_err(&pdev->dev, "Unable to map HPI registers\n");
+                ret = -EIO;
+                goto map_failed;
+        }
+
+        spin_lock_init(&c67x00->hpi.lock);
+        c67x00->hpi.regstep = pdata->hpi_regstep;
+        c67x00->pdata = pdev->dev.platform_data;
+        c67x00->pdev = pdev;
+
+        c67x00_ll_init(c67x00);
+        c67x00_ll_hpi_reg_init(c67x00);
+
+        ret = request_irq(res2->start, c67x00_irq, 0, pdev->name, c67x00);
+        if (ret) {
+                dev_err(&pdev->dev, "Cannot claim IRQ\n");
+                goto request_irq_failed;
+        }
+
+        ret = c67x00_ll_reset(c67x00);
+        if (ret) {
+                dev_err(&pdev->dev, "Device reset failed\n");
+                goto reset_failed;
+        }
+
+        for (i = 0; i < C67X00_SIES; i++)
+                c67x00_probe_sie(&c67x00->sie[i], c67x00, i);
+
+        platform_set_drvdata(pdev, c67x00);
+
+        return 0;
+
+ reset_failed:
+        free_irq(res2->start, c67x00);
+ request_irq_failed:
+        iounmap(c67x00->hpi.base);
+ map_failed:
+        release_mem_region(res->start, res->end - res->start + 1);
+ request_mem_failed:
+        kfree(c67x00);
+
+        return ret;
+}
+
+static int __devexit c67x00_drv_remove(struct platform_device *pdev)
+{
+        struct c67x00_device *c67x00 = platform_get_drvdata(pdev);
+        struct resource *res;
+        int i;
+
+        for (i = 0; i < C67X00_SIES; i++)
+                c67x00_remove_sie(&c67x00->sie[i]);
+
+        c67x00_ll_release(c67x00);
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (res)
+                free_irq(res->start, c67x00);
+
+        iounmap(c67x00->hpi.base);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res)
+                release_mem_region(res->start, res->end - res->start + 1);
+
+        kfree(c67x00);
+
+        return 0;
+}
+
+static struct platform_driver c67x00_driver = {
+        .probe  = c67x00_drv_probe,
+        .remove = __devexit_p(c67x00_drv_remove),
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "c67x00",
+        },
+};
+MODULE_ALIAS("platform:c67x00");
+
+static int __init c67x00_init(void)
+{
+        return platform_driver_register(&c67x00_driver);
+}
+
+static void __exit c67x00_exit(void)
+{
+        platform_driver_unregister(&c67x00_driver);
+}
+
+module_init(c67x00_init);
+module_exit(c67x00_exit);
+
+MODULE_AUTHOR("Peter Korsgaard, Jan Veldeman, Grant Likely");
+MODULE_DESCRIPTION("Cypress C67X00 USB Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/c67x00/c67x00-hcd.c b/drivers/usb/c67x00/c67x00-hcd.c
new file mode 100644
index 000000000000..a22b887f4e9e
--- /dev/null
+++ b/drivers/usb/c67x00/c67x00-hcd.c
@@ -0,0 +1,412 @@
+/*
+ * c67x00-hcd.c: Cypress C67X00 USB Host Controller Driver
+ *
+ * Copyright (C) 2006-2008 Barco N.V.
+ *    Derived from the Cypress cy7c67200/300 ezusb linux driver and
+ *    based on multiple host controller drivers inside the linux kernel.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA.
+ */
+
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/usb.h>
+
+#include "c67x00.h"
+#include "c67x00-hcd.h"
+
+/* --------------------------------------------------------------------------
+ * Root Hub Support
+ */
+
+static __u8 c67x00_hub_des[] = {
+        0x09,                   /*  __u8  bLength; */
+        0x29,                   /*  __u8  bDescriptorType; Hub-descriptor */
+        0x02,                   /*  __u8  bNbrPorts; */
+        0x00,                   /* __u16  wHubCharacteristics; */
+        0x00,                   /*   (per-port OC, no power switching) */
+        0x32,                   /*  __u8  bPwrOn2pwrGood; 2ms */
+        0x00,                   /*  __u8  bHubContrCurrent; 0 mA */
+        0x00,                   /*  __u8  DeviceRemovable; ** 7 Ports max ** */
+        0xff,                   /*  __u8  PortPwrCtrlMask; ** 7 ports max ** */
+};
+
+static void c67x00_hub_reset_host_port(struct c67x00_sie *sie, int port)
+{
+        struct c67x00_hcd *c67x00 = sie->private_data;
+        unsigned long flags;
+
+        c67x00_ll_husb_reset(sie, port);
+
+        spin_lock_irqsave(&c67x00->lock, flags);
+        c67x00_ll_husb_reset_port(sie, port);
+        spin_unlock_irqrestore(&c67x00->lock, flags);
+
+        c67x00_ll_set_husb_eot(sie->dev, DEFAULT_EOT);
+}
+
+static int c67x00_hub_status_data(struct usb_hcd *hcd, char *buf)
+{
+        struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
+        struct c67x00_sie *sie = c67x00->sie;
+        u16 status;
+        int i;
+
+        *buf = 0;
+        status = c67x00_ll_usb_get_status(sie);
+        for (i = 0; i < C67X00_PORTS; i++)
+                if (status & PORT_CONNECT_CHANGE(i))
+                        *buf |= (1 << i);
+
+        /* bit 0 denotes hub change, b1..n port change */
+        *buf <<= 1;
+
+        return !!*buf;
+}
+
+static int c67x00_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                              u16 wIndex, char *buf, u16 wLength)
+{
+        struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
+        struct c67x00_sie *sie = c67x00->sie;
+        u16 status, usb_status;
+        int len = 0;
+        unsigned int port = wIndex-1;
+        u16 wPortChange, wPortStatus;
+
+        switch (typeReq) {
+
+        case GetHubStatus:
+                *(__le32 *) buf = cpu_to_le32(0);
+                len = 4;                /* hub power */
+                break;
+
+        case GetPortStatus:
+                if (wIndex > C67X00_PORTS)
+                        return -EPIPE;
+
+                status = c67x00_ll_usb_get_status(sie);
+                usb_status = c67x00_ll_get_usb_ctl(sie);
+
+                wPortChange = 0;
+                if (status & PORT_CONNECT_CHANGE(port))
+                        wPortChange |= USB_PORT_STAT_C_CONNECTION;
+
+                wPortStatus = USB_PORT_STAT_POWER;
+                if (!(status & PORT_SE0_STATUS(port)))
+                        wPortStatus |= USB_PORT_STAT_CONNECTION;
+                if (usb_status & LOW_SPEED_PORT(port)) {
+                        wPortStatus |= USB_PORT_STAT_LOW_SPEED;
+                        c67x00->low_speed_ports |= (1 << port);
+                } else
+                        c67x00->low_speed_ports &= ~(1 << port);
+
+                if (usb_status & SOF_EOP_EN(port))
+                        wPortStatus |= USB_PORT_STAT_ENABLE;
+
+                *(__le16 *) buf = cpu_to_le16(wPortStatus);
+                *(__le16 *) (buf + 2) = cpu_to_le16(wPortChange);
+                len = 4;
+                break;
+
+        case SetHubFeature:     /* We don't implement these */
+        case ClearHubFeature:
+                switch (wValue) {
+                case C_HUB_OVER_CURRENT:
+                case C_HUB_LOCAL_POWER:
+                        len = 0;
+                        break;
+
+                default:
+                        return -EPIPE;
+                }
+                break;
+
+        case SetPortFeature:
+                if (wIndex > C67X00_PORTS)
+                        return -EPIPE;
+
+                switch (wValue) {
+                case USB_PORT_FEAT_SUSPEND:
+                        dev_dbg(c67x00_hcd_dev(c67x00),
+                                "SetPortFeature %d (SUSPEND)\n", port);
+                        len = 0;
+                        break;
+
+                case USB_PORT_FEAT_RESET:
+                        c67x00_hub_reset_host_port(sie, port);
+                        len = 0;
+                        break;
+
+                case USB_PORT_FEAT_POWER:
+                        /* Power always enabled */
+                        len = 0;
+                        break;
+
+                default:
+                        dev_dbg(c67x00_hcd_dev(c67x00),
+                                "%s: SetPortFeature %d (0x%04x) Error!\n",
+                                __func__, port, wValue);
+                        return -EPIPE;
+                }
+                break;
+
+        case ClearPortFeature:
+                if (wIndex > C67X00_PORTS)
+                        return -EPIPE;
+
+                switch (wValue) {
+                case USB_PORT_FEAT_ENABLE:
+                        /* Reset the port so that the c67x00 also notices the
+                         * disconnect */
+                        c67x00_hub_reset_host_port(sie, port);
+                        len = 0;
+                        break;
+
+                case USB_PORT_FEAT_C_ENABLE:
+                        dev_dbg(c67x00_hcd_dev(c67x00),
+                                "ClearPortFeature (%d): C_ENABLE\n", port);
+                        len = 0;
+                        break;
+
+                case USB_PORT_FEAT_SUSPEND:
+                        dev_dbg(c67x00_hcd_dev(c67x00),
+                                "ClearPortFeature (%d): SUSPEND\n", port);
+                        len = 0;
+                        break;
+
+                case USB_PORT_FEAT_C_SUSPEND:
+                        dev_dbg(c67x00_hcd_dev(c67x00),
+                                "ClearPortFeature (%d): C_SUSPEND\n", port);
+                        len = 0;
+                        break;
+
+                case USB_PORT_FEAT_POWER:
+                        dev_dbg(c67x00_hcd_dev(c67x00),
+                                "ClearPortFeature (%d): POWER\n", port);
+                        return -EPIPE;
+
+                case USB_PORT_FEAT_C_CONNECTION:
+                        c67x00_ll_usb_clear_status(sie,
+                                                   PORT_CONNECT_CHANGE(port));
+                        len = 0;
+                        break;
+
+                case USB_PORT_FEAT_C_OVER_CURRENT:
+                        dev_dbg(c67x00_hcd_dev(c67x00),
+                                "ClearPortFeature (%d): OVER_CURRENT\n", port);
+                        len = 0;
+                        break;
+
+                case USB_PORT_FEAT_C_RESET:
+                        dev_dbg(c67x00_hcd_dev(c67x00),
+                                "ClearPortFeature (%d): C_RESET\n", port);
+                        len = 0;
+                        break;
+
+                default:
+                        dev_dbg(c67x00_hcd_dev(c67x00),
+                                "%s: ClearPortFeature %d (0x%04x) Error!\n",
+                                __func__, port, wValue);
+                        return -EPIPE;
+                }
+                break;
+
+        case GetHubDescriptor:
+                len = min_t(unsigned int, sizeof(c67x00_hub_des), wLength);
+                memcpy(buf, c67x00_hub_des, len);
+                break;
+
+        default:
+                dev_dbg(c67x00_hcd_dev(c67x00), "%s: unknown\n", __func__);
+                return -EPIPE;
+        }
+
+        return 0;
+}
+
+/* ---------------------------------------------------------------------
+ * Main part of host controller driver
+ */
+
+/**
+ * c67x00_hcd_irq
+ *
+ * This function is called from the interrupt handler in c67x00-drv.c
+ */
+static void c67x00_hcd_irq(struct c67x00_sie *sie, u16 int_status, u16 msg)
+{
+        struct c67x00_hcd *c67x00 = sie->private_data;
+        struct usb_hcd *hcd = c67x00_hcd_to_hcd(c67x00);
+
+        /* Handle sie message flags */
+        if (msg) {
+                if (msg & HUSB_TDListDone)
+                        c67x00_sched_kick(c67x00);
+                else
+                        dev_warn(c67x00_hcd_dev(c67x00),
+                                 "Unknown SIE msg flag(s): 0x%04x\n", msg);
+        }
+
+        if (unlikely(hcd->state == HC_STATE_HALT))
+                return;
+
+        if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
+                return;
+
+        /* Handle Start of frame events */
+        if (int_status & SOFEOP_FLG(sie->sie_num)) {
+                c67x00_ll_usb_clear_status(sie, SOF_EOP_IRQ_FLG);
+                c67x00_sched_kick(c67x00);
+                set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
+        }
+}
+
+/**
+ * c67x00_hcd_start: Host controller start hook
+ */
+static int c67x00_hcd_start(struct usb_hcd *hcd)
+{
+        hcd->uses_new_polling = 1;
+        hcd->state = HC_STATE_RUNNING;
+        hcd->poll_rh = 1;
+
+        return 0;
+}
+
+/**
+ * c67x00_hcd_stop: Host controller stop hook
+ */
+static void c67x00_hcd_stop(struct usb_hcd *hcd)
+{
+        /* Nothing to do */
+}
+
+static int c67x00_hcd_get_frame(struct usb_hcd *hcd)
+{
+        struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
+        u16 temp_val;
+
+        dev_dbg(c67x00_hcd_dev(c67x00), "%s\n", __func__);
+        temp_val = c67x00_ll_husb_get_frame(c67x00->sie);
+        temp_val &= HOST_FRAME_MASK;
+        return temp_val ? (temp_val - 1) : HOST_FRAME_MASK;
+}
+
+static struct hc_driver c67x00_hc_driver = {
+        .description    = "c67x00-hcd",
+        .product_desc   = "Cypress C67X00 Host Controller",
+        .hcd_priv_size  = sizeof(struct c67x00_hcd),
+        .flags          = HCD_USB11 | HCD_MEMORY,
+
+        /*
+         * basic lifecycle operations
+         */
+        .start          = c67x00_hcd_start,
+        .stop           = c67x00_hcd_stop,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue    = c67x00_urb_enqueue,
+        .urb_dequeue    = c67x00_urb_dequeue,
+        .endpoint_disable = c67x00_endpoint_disable,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number = c67x00_hcd_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data = c67x00_hub_status_data,
+        .hub_control    = c67x00_hub_control,
+};
+
+/* ---------------------------------------------------------------------
+ * Setup/Teardown routines
+ */
+
+int c67x00_hcd_probe(struct c67x00_sie *sie)
+{
+        struct c67x00_hcd *c67x00;
+        struct usb_hcd *hcd;
+        unsigned long flags;
+        int retval;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        hcd = usb_create_hcd(&c67x00_hc_driver, sie_dev(sie), "c67x00_sie");
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto err0;
+        }
+        c67x00 = hcd_to_c67x00_hcd(hcd);
+
+        spin_lock_init(&c67x00->lock);
+        c67x00->sie = sie;
+
+        INIT_LIST_HEAD(&c67x00->list[PIPE_ISOCHRONOUS]);
+        INIT_LIST_HEAD(&c67x00->list[PIPE_INTERRUPT]);
+        INIT_LIST_HEAD(&c67x00->list[PIPE_CONTROL]);
+        INIT_LIST_HEAD(&c67x00->list[PIPE_BULK]);
+        c67x00->urb_count = 0;
+        INIT_LIST_HEAD(&c67x00->td_list);
+        c67x00->td_base_addr = CY_HCD_BUF_ADDR + SIE_TD_OFFSET(sie->sie_num);
+        c67x00->buf_base_addr = CY_HCD_BUF_ADDR + SIE_BUF_OFFSET(sie->sie_num);
+        c67x00->max_frame_bw = MAX_FRAME_BW_STD;
+
+        c67x00_ll_husb_init_host_port(sie);
+
+        init_completion(&c67x00->endpoint_disable);
+        retval = c67x00_sched_start_scheduler(c67x00);
+        if (retval)
+                goto err1;
+
+        retval = usb_add_hcd(hcd, 0, 0);
+        if (retval) {
+                dev_dbg(sie_dev(sie), "%s: usb_add_hcd returned %d\n",
+                        __func__, retval);
+                goto err2;
+        }
+
+        spin_lock_irqsave(&sie->lock, flags);
+        sie->private_data = c67x00;
+        sie->irq = c67x00_hcd_irq;
+        spin_unlock_irqrestore(&sie->lock, flags);
+
+        return retval;
+
+ err2:
+        c67x00_sched_stop_scheduler(c67x00);
+ err1:
+        usb_put_hcd(hcd);
+ err0:
+        return retval;
+}
+
+/* may be called with controller, bus, and devices active */
+void c67x00_hcd_remove(struct c67x00_sie *sie)
+{
+        struct c67x00_hcd *c67x00 = sie->private_data;
+        struct usb_hcd *hcd = c67x00_hcd_to_hcd(c67x00);
+
+        c67x00_sched_stop_scheduler(c67x00);
+        usb_remove_hcd(hcd);
+        usb_put_hcd(hcd);
+}
diff --git a/drivers/usb/c67x00/c67x00-hcd.h b/drivers/usb/c67x00/c67x00-hcd.h
new file mode 100644
index 000000000000..e8c6d94b2514
--- /dev/null
+++ b/drivers/usb/c67x00/c67x00-hcd.h
@@ -0,0 +1,133 @@
+/*
+ * c67x00-hcd.h: Cypress C67X00 USB HCD
+ *
+ * Copyright (C) 2006-2008 Barco N.V.
+ *    Derived from the Cypress cy7c67200/300 ezusb linux driver and
+ *    based on multiple host controller drivers inside the linux kernel.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA.
+ */
+
+#ifndef _USB_C67X00_HCD_H
+#define _USB_C67X00_HCD_H
+
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/list.h>
+#include <linux/usb.h>
+#include "../core/hcd.h"
+#include "c67x00.h"
+
+/*
+ * The following parameters depend on the CPU speed, bus speed, ...
+ * These can be tuned for specific use cases, e.g. if isochronous transfers
+ * are very important, bandwith can be sacrificed to guarantee that the
+ * 1ms deadline will be met.
+ * If bulk transfers are important, the MAX_FRAME_BW can be increased,
+ * but some (or many) isochronous deadlines might not be met.
+ *
+ * The values are specified in bittime.
+ */
+
+/*
+ * The current implementation switches between _STD (default) and _ISO (when
+ * isochronous transfers are scheduled), in order to optimize the throughput
+ * in normal cicrumstances, but also provide good isochronous behaviour.
+ *
+ * Bandwidth is described in bit time so with a 12MHz USB clock and 1ms
+ * frames; there are 12000 bit times per frame.
+ */
+
+#define TOTAL_FRAME_BW          12000
+#define DEFAULT_EOT             2250
+
+#define MAX_FRAME_BW_STD        (TOTAL_FRAME_BW - DEFAULT_EOT)
+#define MAX_FRAME_BW_ISO        2400
+
+/*
+ * Periodic transfers may only use 90% of the full frame, but as
+ * we currently don't even use 90% of the full frame, we may
+ * use the full usable time for periodic transfers.
+ */
+#define MAX_PERIODIC_BW(full_bw)        full_bw
+
+/* -------------------------------------------------------------------------- */
+
+struct c67x00_hcd {
+        spinlock_t lock;
+        struct c67x00_sie *sie;
+        unsigned int low_speed_ports;   /* bitmask of low speed ports */
+        unsigned int urb_count;
+        unsigned int urb_iso_count;
+
+        struct list_head list[4];       /* iso, int, ctrl, bulk */
+#if PIPE_BULK != 3
+#error "Sanity check failed, this code presumes PIPE_... to range from 0 to 3"
+#endif
+
+        /* USB bandwidth allocated to td_list */
+        int bandwidth_allocated;
+        /* USB bandwidth allocated for isoc/int transfer */
+        int periodic_bw_allocated;
+        struct list_head td_list;
+        int max_frame_bw;
+
+        u16 td_base_addr;
+        u16 buf_base_addr;
+        u16 next_td_addr;
+        u16 next_buf_addr;
+
+        struct tasklet_struct tasklet;
+
+        struct completion endpoint_disable;
+
+        u16 current_frame;
+        u16 last_frame;
+};
+
+static inline struct c67x00_hcd *hcd_to_c67x00_hcd(struct usb_hcd *hcd)
+{
+        return (struct c67x00_hcd *)(hcd->hcd_priv);
+}
+
+static inline struct usb_hcd *c67x00_hcd_to_hcd(struct c67x00_hcd *c67x00)
+{
+        return container_of((void *)c67x00, struct usb_hcd, hcd_priv);
+}
+
+/* ---------------------------------------------------------------------
+ * Functions used by c67x00-drv
+ */
+
+int c67x00_hcd_probe(struct c67x00_sie *sie);
+void c67x00_hcd_remove(struct c67x00_sie *sie);
+
+/* ---------------------------------------------------------------------
+ * Transfer Descriptor scheduling functions
+ */
+int c67x00_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags);
+int c67x00_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status);
+void c67x00_endpoint_disable(struct usb_hcd *hcd,
+                             struct usb_host_endpoint *ep);
+
+void c67x00_hcd_msg_received(struct c67x00_sie *sie, u16 msg);
+void c67x00_sched_kick(struct c67x00_hcd *c67x00);
+int c67x00_sched_start_scheduler(struct c67x00_hcd *c67x00);
+void c67x00_sched_stop_scheduler(struct c67x00_hcd *c67x00);
+
+#define c67x00_hcd_dev(x)       (c67x00_hcd_to_hcd(x)->self.controller)
+
+#endif                          /* _USB_C67X00_HCD_H */
diff --git a/drivers/usb/c67x00/c67x00-ll-hpi.c b/drivers/usb/c67x00/c67x00-ll-hpi.c
new file mode 100644
index 000000000000..a9636f43bca2
--- /dev/null
+++ b/drivers/usb/c67x00/c67x00-ll-hpi.c
@@ -0,0 +1,481 @@
+/*
+ * c67x00-ll-hpi.c: Cypress C67X00 USB Low level interface using HPI
+ *
+ * Copyright (C) 2006-2008 Barco N.V.
+ *    Derived from the Cypress cy7c67200/300 ezusb linux driver and
+ *    based on multiple host controller drivers inside the linux kernel.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA.
+ */
+
+#include <asm/byteorder.h>
+#include <linux/io.h>
+#include <linux/jiffies.h>
+#include <linux/usb/c67x00.h>
+#include "c67x00.h"
+
+#define COMM_REGS 14
+
+struct c67x00_lcp_int_data {
+        u16 regs[COMM_REGS];
+};
+
+/* -------------------------------------------------------------------------- */
+/* Interface definitions */
+
+#define COMM_ACK                        0x0FED
+#define COMM_NAK                        0xDEAD
+
+#define COMM_RESET                      0xFA50
+#define COMM_EXEC_INT                   0xCE01
+#define COMM_INT_NUM                    0x01C2
+
+/* Registers 0 to COMM_REGS-1 */
+#define COMM_R(x)                       (0x01C4 + 2 * (x))
+
+#define HUSB_SIE_pCurrentTDPtr(x)       ((x) ? 0x01B2 : 0x01B0)
+#define HUSB_SIE_pTDListDone_Sem(x)     ((x) ? 0x01B8 : 0x01B6)
+#define HUSB_pEOT                       0x01B4
+
+/* Software interrupts */
+/* 114, 115: */
+#define HUSB_SIE_INIT_INT(x)            ((x) ? 0x0073 : 0x0072)
+#define HUSB_RESET_INT                  0x0074
+
+#define SUSB_INIT_INT                   0x0071
+#define SUSB_INIT_INT_LOC               (SUSB_INIT_INT * 2)
+
+/* -----------------------------------------------------------------------
+ * HPI implementation
+ *
+ * The c67x00 chip also support control via SPI or HSS serial
+ * interfaces.  However, this driver assumes that register access can
+ * be performed from IRQ context.  While this is a safe assuption with
+ * the HPI interface, it is not true for the serial interfaces.
+ */
+
+/* HPI registers */
+#define HPI_DATA        0
+#define HPI_MAILBOX     1
+#define HPI_ADDR        2
+#define HPI_STATUS      3
+
+static inline u16 hpi_read_reg(struct c67x00_device *dev, int reg)
+{
+        return __raw_readw(dev->hpi.base + reg * dev->hpi.regstep);
+}
+
+static inline void hpi_write_reg(struct c67x00_device *dev, int reg, u16 value)
+{
+        __raw_writew(value, dev->hpi.base + reg * dev->hpi.regstep);
+}
+
+static inline u16 hpi_read_word_nolock(struct c67x00_device *dev, u16 reg)
+{
+        hpi_write_reg(dev, HPI_ADDR, reg);
+        return hpi_read_reg(dev, HPI_DATA);
+}
+
+static u16 hpi_read_word(struct c67x00_device *dev, u16 reg)
+{
+        u16 value;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->hpi.lock, flags);
+        value = hpi_read_word_nolock(dev, reg);
+        spin_unlock_irqrestore(&dev->hpi.lock, flags);
+
+        return value;
+}
+
+static void hpi_write_word_nolock(struct c67x00_device *dev, u16 reg, u16 value)
+{
+        hpi_write_reg(dev, HPI_ADDR, reg);
+        hpi_write_reg(dev, HPI_DATA, value);
+}
+
+static void hpi_write_word(struct c67x00_device *dev, u16 reg, u16 value)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->hpi.lock, flags);
+        hpi_write_word_nolock(dev, reg, value);
+        spin_unlock_irqrestore(&dev->hpi.lock, flags);
+}
+
+/*
+ * Only data is little endian, addr has cpu endianess
+ */
+static void hpi_write_words_le16(struct c67x00_device *dev, u16 addr,
+                                 __le16 *data, u16 count)
+{
+        unsigned long flags;
+        int i;
+
+        spin_lock_irqsave(&dev->hpi.lock, flags);
+
+        hpi_write_reg(dev, HPI_ADDR, addr);
+        for (i = 0; i < count; i++)
+                hpi_write_reg(dev, HPI_DATA, le16_to_cpu(*data++));
+
+        spin_unlock_irqrestore(&dev->hpi.lock, flags);
+}
+
+/*
+ * Only data is little endian, addr has cpu endianess
+ */
+static void hpi_read_words_le16(struct c67x00_device *dev, u16 addr,
+                                __le16 *data, u16 count)
+{
+        unsigned long flags;
+        int i;
+
+        spin_lock_irqsave(&dev->hpi.lock, flags);
+        hpi_write_reg(dev, HPI_ADDR, addr);
+        for (i = 0; i < count; i++)
+                *data++ = cpu_to_le16(hpi_read_reg(dev, HPI_DATA));
+
+        spin_unlock_irqrestore(&dev->hpi.lock, flags);
+}
+
+static void hpi_set_bits(struct c67x00_device *dev, u16 reg, u16 mask)
+{
+        u16 value;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->hpi.lock, flags);
+        value = hpi_read_word_nolock(dev, reg);
+        hpi_write_word_nolock(dev, reg, value | mask);
+        spin_unlock_irqrestore(&dev->hpi.lock, flags);
+}
+
+static void hpi_clear_bits(struct c67x00_device *dev, u16 reg, u16 mask)
+{
+        u16 value;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->hpi.lock, flags);
+        value = hpi_read_word_nolock(dev, reg);
+        hpi_write_word_nolock(dev, reg, value & ~mask);
+        spin_unlock_irqrestore(&dev->hpi.lock, flags);
+}
+
+static u16 hpi_recv_mbox(struct c67x00_device *dev)
+{
+        u16 value;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->hpi.lock, flags);
+        value = hpi_read_reg(dev, HPI_MAILBOX);
+        spin_unlock_irqrestore(&dev->hpi.lock, flags);
+
+        return value;
+}
+
+static u16 hpi_send_mbox(struct c67x00_device *dev, u16 value)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->hpi.lock, flags);
+        hpi_write_reg(dev, HPI_MAILBOX, value);
+        spin_unlock_irqrestore(&dev->hpi.lock, flags);
+
+        return value;
+}
+
+u16 c67x00_ll_hpi_status(struct c67x00_device *dev)
+{
+        u16 value;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->hpi.lock, flags);
+        value = hpi_read_reg(dev, HPI_STATUS);
+        spin_unlock_irqrestore(&dev->hpi.lock, flags);
+
+        return value;
+}
+
+void c67x00_ll_hpi_reg_init(struct c67x00_device *dev)
+{
+        int i;
+
+        hpi_recv_mbox(dev);
+        c67x00_ll_hpi_status(dev);
+        hpi_write_word(dev, HPI_IRQ_ROUTING_REG, 0);
+
+        for (i = 0; i < C67X00_SIES; i++) {
+                hpi_write_word(dev, SIEMSG_REG(i), 0);
+                hpi_read_word(dev, SIEMSG_REG(i));
+        }
+}
+
+void c67x00_ll_hpi_enable_sofeop(struct c67x00_sie *sie)
+{
+        hpi_set_bits(sie->dev, HPI_IRQ_ROUTING_REG,
+                     SOFEOP_TO_HPI_EN(sie->sie_num));
+}
+
+void c67x00_ll_hpi_disable_sofeop(struct c67x00_sie *sie)
+{
+        hpi_clear_bits(sie->dev, HPI_IRQ_ROUTING_REG,
+                       SOFEOP_TO_HPI_EN(sie->sie_num));
+}
+
+/* -------------------------------------------------------------------------- */
+/* Transactions */
+
+static inline u16 ll_recv_msg(struct c67x00_device *dev)
+{
+        u16 res;
+
+        res = wait_for_completion_timeout(&dev->hpi.lcp.msg_received, 5 * HZ);
+        WARN_ON(!res);
+
+        return (res == 0) ? -EIO : 0;
+}
+
+/* -------------------------------------------------------------------------- */
+/* General functions */
+
+u16 c67x00_ll_fetch_siemsg(struct c67x00_device *dev, int sie_num)
+{
+        u16 val;
+
+        val = hpi_read_word(dev, SIEMSG_REG(sie_num));
+        /* clear register to allow next message */
+        hpi_write_word(dev, SIEMSG_REG(sie_num), 0);
+
+        return val;
+}
+
+u16 c67x00_ll_get_usb_ctl(struct c67x00_sie *sie)
+{
+        return hpi_read_word(sie->dev, USB_CTL_REG(sie->sie_num));
+}
+
+/**
+ * c67x00_ll_usb_clear_status - clear the USB status bits
+ */
+void c67x00_ll_usb_clear_status(struct c67x00_sie *sie, u16 bits)
+{
+        hpi_write_word(sie->dev, USB_STAT_REG(sie->sie_num), bits);
+}
+
+u16 c67x00_ll_usb_get_status(struct c67x00_sie *sie)
+{
+        return hpi_read_word(sie->dev, USB_STAT_REG(sie->sie_num));
+}
+
+/* -------------------------------------------------------------------------- */
+
+static int c67x00_comm_exec_int(struct c67x00_device *dev, u16 nr,
+                                struct c67x00_lcp_int_data *data)
+{
+        int i, rc;
+
+        mutex_lock(&dev->hpi.lcp.mutex);
+        hpi_write_word(dev, COMM_INT_NUM, nr);
+        for (i = 0; i < COMM_REGS; i++)
+                hpi_write_word(dev, COMM_R(i), data->regs[i]);
+        hpi_send_mbox(dev, COMM_EXEC_INT);
+        rc = ll_recv_msg(dev);
+        mutex_unlock(&dev->hpi.lcp.mutex);
+
+        return rc;
+}
+
+/* -------------------------------------------------------------------------- */
+/* Host specific functions */
+
+void c67x00_ll_set_husb_eot(struct c67x00_device *dev, u16 value)
+{
+        mutex_lock(&dev->hpi.lcp.mutex);
+        hpi_write_word(dev, HUSB_pEOT, value);
+        mutex_unlock(&dev->hpi.lcp.mutex);
+}
+
+static inline void c67x00_ll_husb_sie_init(struct c67x00_sie *sie)
+{
+        struct c67x00_device *dev = sie->dev;
+        struct c67x00_lcp_int_data data;
+        int rc;
+
+        rc = c67x00_comm_exec_int(dev, HUSB_SIE_INIT_INT(sie->sie_num), &data);
+        BUG_ON(rc); /* No return path for error code; crash spectacularly */
+}
+
+void c67x00_ll_husb_reset(struct c67x00_sie *sie, int port)
+{
+        struct c67x00_device *dev = sie->dev;
+        struct c67x00_lcp_int_data data;
+        int rc;
+
+        data.regs[0] = 50;      /* Reset USB port for 50ms */
+        data.regs[1] = port | (sie->sie_num << 1);
+        rc = c67x00_comm_exec_int(dev, HUSB_RESET_INT, &data);
+        BUG_ON(rc); /* No return path for error code; crash spectacularly */
+}
+
+void c67x00_ll_husb_set_current_td(struct c67x00_sie *sie, u16 addr)
+{
+        hpi_write_word(sie->dev, HUSB_SIE_pCurrentTDPtr(sie->sie_num), addr);
+}
+
+u16 c67x00_ll_husb_get_current_td(struct c67x00_sie *sie)
+{
+        return hpi_read_word(sie->dev, HUSB_SIE_pCurrentTDPtr(sie->sie_num));
+}
+
+u16 c67x00_ll_husb_get_frame(struct c67x00_sie *sie)
+{
+        return hpi_read_word(sie->dev, HOST_FRAME_REG(sie->sie_num));
+}
+
+void c67x00_ll_husb_init_host_port(struct c67x00_sie *sie)
+{
+        /* Set port into host mode */
+        hpi_set_bits(sie->dev, USB_CTL_REG(sie->sie_num), HOST_MODE);
+        c67x00_ll_husb_sie_init(sie);
+        /* Clear interrupts */
+        c67x00_ll_usb_clear_status(sie, HOST_STAT_MASK);
+        /* Check */
+        if (!(hpi_read_word(sie->dev, USB_CTL_REG(sie->sie_num)) & HOST_MODE))
+                dev_warn(sie_dev(sie),
+                         "SIE %d not set to host mode\n", sie->sie_num);
+}
+
+void c67x00_ll_husb_reset_port(struct c67x00_sie *sie, int port)
+{
+        /* Clear connect change */
+        c67x00_ll_usb_clear_status(sie, PORT_CONNECT_CHANGE(port));
+
+        /* Enable interrupts */
+        hpi_set_bits(sie->dev, HPI_IRQ_ROUTING_REG,
+                     SOFEOP_TO_CPU_EN(sie->sie_num));
+        hpi_set_bits(sie->dev, HOST_IRQ_EN_REG(sie->sie_num),
+                     SOF_EOP_IRQ_EN | DONE_IRQ_EN);
+
+        /* Enable pull down transistors */
+        hpi_set_bits(sie->dev, USB_CTL_REG(sie->sie_num), PORT_RES_EN(port));
+}
+
+/* -------------------------------------------------------------------------- */
+
+void c67x00_ll_irq(struct c67x00_device *dev, u16 int_status)
+{
+        if ((int_status & MBX_OUT_FLG) == 0)
+                return;
+
+        dev->hpi.lcp.last_msg = hpi_recv_mbox(dev);
+        complete(&dev->hpi.lcp.msg_received);
+}
+
+/* -------------------------------------------------------------------------- */
+
+int c67x00_ll_reset(struct c67x00_device *dev)
+{
+        int rc;
+
+        mutex_lock(&dev->hpi.lcp.mutex);
+        hpi_send_mbox(dev, COMM_RESET);
+        rc = ll_recv_msg(dev);
+        mutex_unlock(&dev->hpi.lcp.mutex);
+
+        return rc;
+}
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * c67x00_ll_write_mem_le16 - write into c67x00 memory
+ * Only data is little endian, addr has cpu endianess.
+ */
+void c67x00_ll_write_mem_le16(struct c67x00_device *dev, u16 addr,
+                              void *data, int len)
+{
+        u8 *buf = data;
+
+        /* Sanity check */
+        if (addr + len > 0xffff) {
+                dev_err(&dev->pdev->dev,
+                        "Trying to write beyond writable region!\n");
+                return;
+        }
+
+        if (addr & 0x01) {
+                /* unaligned access */
+                u16 tmp;
+                tmp = hpi_read_word(dev, addr - 1);
+                tmp = (tmp & 0x00ff) | (*buf++ << 8);
+                hpi_write_word(dev, addr - 1, tmp);
+                addr++;
+                len--;
+        }
+
+        hpi_write_words_le16(dev, addr, (__le16 *)buf, len / 2);
+        buf += len & ~0x01;
+        addr += len & ~0x01;
+        len &= 0x01;
+
+        if (len) {
+                u16 tmp;
+                tmp = hpi_read_word(dev, addr);
+                tmp = (tmp & 0xff00) | *buf;
+                hpi_write_word(dev, addr, tmp);
+        }
+}
+
+/**
+ * c67x00_ll_read_mem_le16 - read from c67x00 memory
+ * Only data is little endian, addr has cpu endianess.
+ */
+void c67x00_ll_read_mem_le16(struct c67x00_device *dev, u16 addr,
+                             void *data, int len)
+{
+        u8 *buf = data;
+
+        if (addr & 0x01) {
+                /* unaligned access */
+                u16 tmp;
+                tmp = hpi_read_word(dev, addr - 1);
+                *buf++ = (tmp >> 8) & 0x00ff;
+                addr++;
+                len--;
+        }
+
+        hpi_read_words_le16(dev, addr, (__le16 *)buf, len / 2);
+        buf += len & ~0x01;
+        addr += len & ~0x01;
+        len &= 0x01;
+
+        if (len) {
+                u16 tmp;
+                tmp = hpi_read_word(dev, addr);
+                *buf = tmp & 0x00ff;
+        }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void c67x00_ll_init(struct c67x00_device *dev)
+{
+        mutex_init(&dev->hpi.lcp.mutex);
+        init_completion(&dev->hpi.lcp.msg_received);
+}
+
+void c67x00_ll_release(struct c67x00_device *dev)
+{
+}
diff --git a/drivers/usb/c67x00/c67x00-sched.c b/drivers/usb/c67x00/c67x00-sched.c
new file mode 100644
index 000000000000..85dfe2965661
--- /dev/null
+++ b/drivers/usb/c67x00/c67x00-sched.c
@@ -0,0 +1,1170 @@
+/*
+ * c67x00-sched.c: Cypress C67X00 USB Host Controller Driver - TD scheduling
+ *
+ * Copyright (C) 2006-2008 Barco N.V.
+ *    Derived from the Cypress cy7c67200/300 ezusb linux driver and
+ *    based on multiple host controller drivers inside the linux kernel.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA.
+ */
+
+#include <linux/kthread.h>
+
+#include "c67x00.h"
+#include "c67x00-hcd.h"
+
+/*
+ * These are the stages for a control urb, they are kept
+ * in both urb->interval and td->privdata.
+ */
+#define SETUP_STAGE             0
+#define DATA_STAGE              1
+#define STATUS_STAGE            2
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * struct c67x00_ep_data: Host endpoint data structure
+ */
+struct c67x00_ep_data {
+        struct list_head queue;
+        struct list_head node;
+        struct usb_host_endpoint *hep;
+        struct usb_device *dev;
+        u16 next_frame;         /* For int/isoc transactions */
+};
+
+/**
+ * struct c67x00_td
+ *
+ * Hardware parts are little endiannes, SW in CPU endianess.
+ */
+struct c67x00_td {
+        /* HW specific part */
+        __le16 ly_base_addr;    /* Bytes 0-1 */
+        __le16 port_length;     /* Bytes 2-3 */
+        u8 pid_ep;              /* Byte 4 */
+        u8 dev_addr;            /* Byte 5 */
+        u8 ctrl_reg;            /* Byte 6 */
+        u8 status;              /* Byte 7 */
+        u8 retry_cnt;           /* Byte 8 */
+#define TT_OFFSET               2
+#define TT_CONTROL              0
+#define TT_ISOCHRONOUS          1
+#define TT_BULK                 2
+#define TT_INTERRUPT            3
+        u8 residue;             /* Byte 9 */
+        __le16 next_td_addr;    /* Bytes 10-11 */
+        /* SW part */
+        struct list_head td_list;
+        u16 td_addr;
+        void *data;
+        struct urb *urb;
+        unsigned long privdata;
+
+        /* These are needed for handling the toggle bits:
+         * an urb can be dequeued while a td is in progress
+         * after checking the td, the toggle bit might need to
+         * be fixed */
+        struct c67x00_ep_data *ep_data;
+        unsigned int pipe;
+};
+
+struct c67x00_urb_priv {
+        struct list_head hep_node;
+        struct urb *urb;
+        int port;
+        int cnt;                /* packet number for isoc */
+        int status;
+        struct c67x00_ep_data *ep_data;
+};
+
+#define td_udev(td)     ((td)->ep_data->dev)
+
+#define CY_TD_SIZE              12
+
+#define TD_PIDEP_OFFSET         0x04
+#define TD_PIDEPMASK_PID        0xF0
+#define TD_PIDEPMASK_EP         0x0F
+#define TD_PORTLENMASK_DL       0x02FF
+#define TD_PORTLENMASK_PN       0xC000
+
+#define TD_STATUS_OFFSET        0x07
+#define TD_STATUSMASK_ACK       0x01
+#define TD_STATUSMASK_ERR       0x02
+#define TD_STATUSMASK_TMOUT     0x04
+#define TD_STATUSMASK_SEQ       0x08
+#define TD_STATUSMASK_SETUP     0x10
+#define TD_STATUSMASK_OVF       0x20
+#define TD_STATUSMASK_NAK       0x40
+#define TD_STATUSMASK_STALL     0x80
+
+#define TD_ERROR_MASK           (TD_STATUSMASK_ERR | TD_STATUSMASK_TMOUT | \
+                                 TD_STATUSMASK_STALL)
+
+#define TD_RETRYCNT_OFFSET      0x08
+#define TD_RETRYCNTMASK_ACT_FLG 0x10
+#define TD_RETRYCNTMASK_TX_TYPE 0x0C
+#define TD_RETRYCNTMASK_RTY_CNT 0x03
+
+#define TD_RESIDUE_OVERFLOW     0x80
+
+#define TD_PID_IN               0x90
+
+/* Residue: signed 8bits, neg -> OVERFLOW, pos -> UNDERFLOW */
+#define td_residue(td)          ((__s8)(td->residue))
+#define td_ly_base_addr(td)     (__le16_to_cpu((td)->ly_base_addr))
+#define td_port_length(td)      (__le16_to_cpu((td)->port_length))
+#define td_next_td_addr(td)     (__le16_to_cpu((td)->next_td_addr))
+
+#define td_active(td)           ((td)->retry_cnt & TD_RETRYCNTMASK_ACT_FLG)
+#define td_length(td)           (td_port_length(td) & TD_PORTLENMASK_DL)
+
+#define td_sequence_ok(td)      (!td->status || \
+                                 (!(td->status & TD_STATUSMASK_SEQ) ==  \
+                                  !(td->ctrl_reg & SEQ_SEL)))
+
+#define td_acked(td)            (!td->status || \
+                                 (td->status & TD_STATUSMASK_ACK))
+#define td_actual_bytes(td)     (td_length(td) - td_residue(td))
+
+/* -------------------------------------------------------------------------- */
+
+#ifdef DEBUG
+
+/**
+ * dbg_td - Dump the contents of the TD
+ */
+static void dbg_td(struct c67x00_hcd *c67x00, struct c67x00_td *td, char *msg)
+{
+        struct device *dev = c67x00_hcd_dev(c67x00);
+
+        dev_dbg(dev, "### %s at 0x%04x\n", msg, td->td_addr);
+        dev_dbg(dev, "urb:      0x%p\n", td->urb);
+        dev_dbg(dev, "endpoint:   %4d\n", usb_pipeendpoint(td->pipe));
+        dev_dbg(dev, "pipeout:    %4d\n", usb_pipeout(td->pipe));
+        dev_dbg(dev, "ly_base_addr: 0x%04x\n", td_ly_base_addr(td));
+        dev_dbg(dev, "port_length:  0x%04x\n", td_port_length(td));
+        dev_dbg(dev, "pid_ep:         0x%02x\n", td->pid_ep);
+        dev_dbg(dev, "dev_addr:       0x%02x\n", td->dev_addr);
+        dev_dbg(dev, "ctrl_reg:       0x%02x\n", td->ctrl_reg);
+        dev_dbg(dev, "status:         0x%02x\n", td->status);
+        dev_dbg(dev, "retry_cnt:      0x%02x\n", td->retry_cnt);
+        dev_dbg(dev, "residue:        0x%02x\n", td->residue);
+        dev_dbg(dev, "next_td_addr: 0x%04x\n", td_next_td_addr(td));
+        dev_dbg(dev, "data:");
+        print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 16, 1,
+                       td->data, td_length(td), 1);
+}
+#else                           /* DEBUG */
+
+static inline void
+dbg_td(struct c67x00_hcd *c67x00, struct c67x00_td *td, char *msg) { }
+
+#endif                          /* DEBUG */
+
+/* -------------------------------------------------------------------------- */
+/* Helper functions */
+
+static inline u16 c67x00_get_current_frame_number(struct c67x00_hcd *c67x00)
+{
+        return c67x00_ll_husb_get_frame(c67x00->sie) & HOST_FRAME_MASK;
+}
+
+/**
+ * frame_add
+ * Software wraparound for framenumbers.
+ */
+static inline u16 frame_add(u16 a, u16 b)
+{
+        return (a + b) & HOST_FRAME_MASK;
+}
+
+/**
+ * frame_after - is frame a after frame b
+ */
+static inline int frame_after(u16 a, u16 b)
+{
+        return ((HOST_FRAME_MASK + a - b) & HOST_FRAME_MASK) <
+            (HOST_FRAME_MASK / 2);
+}
+
+/**
+ * frame_after_eq - is frame a after or equal to frame b
+ */
+static inline int frame_after_eq(u16 a, u16 b)
+{
+        return ((HOST_FRAME_MASK + 1 + a - b) & HOST_FRAME_MASK) <
+            (HOST_FRAME_MASK / 2);
+}
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * c67x00_release_urb - remove link from all tds to this urb
+ * Disconnects the urb from it's tds, so that it can be given back.
+ * pre: urb->hcpriv != NULL
+ */
+static void c67x00_release_urb(struct c67x00_hcd *c67x00, struct urb *urb)
+{
+        struct c67x00_td *td;
+        struct c67x00_urb_priv *urbp;
+
+        BUG_ON(!urb);
+
+        c67x00->urb_count--;
+
+        if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
+                c67x00->urb_iso_count--;
+                if (c67x00->urb_iso_count == 0)
+                        c67x00->max_frame_bw = MAX_FRAME_BW_STD;
+        }
+
+        /* TODO this might be not so efficient when we've got many urbs!
+         * Alternatives:
+         *   * only clear when needed
+         *   * keep a list of tds with each urbp
+         */
+        list_for_each_entry(td, &c67x00->td_list, td_list)
+                if (urb == td->urb)
+                        td->urb = NULL;
+
+        urbp = urb->hcpriv;
+        urb->hcpriv = NULL;
+        list_del(&urbp->hep_node);
+        kfree(urbp);
+}
+
+/* -------------------------------------------------------------------------- */
+
+static struct c67x00_ep_data *
+c67x00_ep_data_alloc(struct c67x00_hcd *c67x00, struct urb *urb)
+{
+        struct usb_host_endpoint *hep = urb->ep;
+        struct c67x00_ep_data *ep_data;
+        int type;
+
+        c67x00->current_frame = c67x00_get_current_frame_number(c67x00);
+
+        /* Check if endpoint already has a c67x00_ep_data struct allocated */
+        if (hep->hcpriv) {
+                ep_data = hep->hcpriv;
+                if (frame_after(c67x00->current_frame, ep_data->next_frame))
+                        ep_data->next_frame =
+                            frame_add(c67x00->current_frame, 1);
+                return hep->hcpriv;
+        }
+
+        /* Allocate and initialize a new c67x00 endpoint data structure */
+        ep_data = kzalloc(sizeof(*ep_data), GFP_ATOMIC);
+        if (!ep_data)
+                return NULL;
+
+        INIT_LIST_HEAD(&ep_data->queue);
+        INIT_LIST_HEAD(&ep_data->node);
+        ep_data->hep = hep;
+
+        /* hold a reference to udev as long as this endpoint lives,
+         * this is needed to possibly fix the data toggle */
+        ep_data->dev = usb_get_dev(urb->dev);
+        hep->hcpriv = ep_data;
+
+        /* For ISOC and INT endpoints, start ASAP: */
+        ep_data->next_frame = frame_add(c67x00->current_frame, 1);
+
+        /* Add the endpoint data to one of the pipe lists; must be added
+           in order of endpoint address */
+        type = usb_pipetype(urb->pipe);
+        if (list_empty(&ep_data->node)) {
+                list_add(&ep_data->node, &c67x00->list[type]);
+        } else {
+                struct c67x00_ep_data *prev;
+
+                list_for_each_entry(prev, &c67x00->list[type], node) {
+                        if (prev->hep->desc.bEndpointAddress >
+                            hep->desc.bEndpointAddress) {
+                                list_add(&ep_data->node, prev->node.prev);
+                                break;
+                        }
+                }
+        }
+
+        return ep_data;
+}
+
+static int c67x00_ep_data_free(struct usb_host_endpoint *hep)
+{
+        struct c67x00_ep_data *ep_data = hep->hcpriv;
+
+        if (!ep_data)
+                return 0;
+
+        if (!list_empty(&ep_data->queue))
+                return -EBUSY;
+
+        usb_put_dev(ep_data->dev);
+        list_del(&ep_data->queue);
+        list_del(&ep_data->node);
+
+        kfree(ep_data);
+        hep->hcpriv = NULL;
+
+        return 0;
+}
+
+void c67x00_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
+{
+        struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
+        unsigned long flags;
+
+        if (!list_empty(&ep->urb_list))
+                dev_warn(c67x00_hcd_dev(c67x00), "error: urb list not empty\n");
+
+        spin_lock_irqsave(&c67x00->lock, flags);
+
+        /* loop waiting for all transfers in the endpoint queue to complete */
+        while (c67x00_ep_data_free(ep)) {
+                /* Drop the lock so we can sleep waiting for the hardware */
+                spin_unlock_irqrestore(&c67x00->lock, flags);
+
+                /* it could happen that we reinitialize this completion, while
+                 * somebody was waiting for that completion.  The timeout and
+                 * while loop handle such cases, but this might be improved */
+                INIT_COMPLETION(c67x00->endpoint_disable);
+                c67x00_sched_kick(c67x00);
+                wait_for_completion_timeout(&c67x00->endpoint_disable, 1 * HZ);
+
+                spin_lock_irqsave(&c67x00->lock, flags);
+        }
+
+        spin_unlock_irqrestore(&c67x00->lock, flags);
+}
+
+/* -------------------------------------------------------------------------- */
+
+static inline int get_root_port(struct usb_device *dev)
+{
+        while (dev->parent->parent)
+                dev = dev->parent;
+        return dev->portnum;
+}
+
+int c67x00_urb_enqueue(struct usb_hcd *hcd,
+                       struct urb *urb, gfp_t mem_flags)
+{
+        int ret;
+        unsigned long flags;
+        struct c67x00_urb_priv *urbp;
+        struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
+        int port = get_root_port(urb->dev)-1;
+
+        spin_lock_irqsave(&c67x00->lock, flags);
+
+        /* Make sure host controller is running */
+        if (!HC_IS_RUNNING(hcd->state)) {
+                ret = -ENODEV;
+                goto err_not_linked;
+        }
+
+        ret = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (ret)
+                goto err_not_linked;
+
+        /* Allocate and initialize urb private data */
+        urbp = kzalloc(sizeof(*urbp), mem_flags);
+        if (!urbp) {
+                ret = -ENOMEM;
+                goto err_urbp;
+        }
+
+        INIT_LIST_HEAD(&urbp->hep_node);
+        urbp->urb = urb;
+        urbp->port = port;
+
+        urbp->ep_data = c67x00_ep_data_alloc(c67x00, urb);
+
+        if (!urbp->ep_data) {
+                ret = -ENOMEM;
+                goto err_epdata;
+        }
+
+        /* TODO claim bandwidth with usb_claim_bandwidth?
+         * also release it somewhere! */
+
+        urb->hcpriv = urbp;
+
+        urb->actual_length = 0; /* Nothing received/transmitted yet */
+
+        switch (usb_pipetype(urb->pipe)) {
+        case PIPE_CONTROL:
+                urb->interval = SETUP_STAGE;
+                break;
+        case PIPE_INTERRUPT:
+                break;
+        case PIPE_BULK:
+                break;
+        case PIPE_ISOCHRONOUS:
+                if (c67x00->urb_iso_count == 0)
+                        c67x00->max_frame_bw = MAX_FRAME_BW_ISO;
+                c67x00->urb_iso_count++;
+                /* Assume always URB_ISO_ASAP, FIXME */
+                if (list_empty(&urbp->ep_data->queue))
+                        urb->start_frame = urbp->ep_data->next_frame;
+                else {
+                        /* Go right after the last one */
+                        struct urb *last_urb;
+
+                        last_urb = list_entry(urbp->ep_data->queue.prev,
+                                              struct c67x00_urb_priv,
+                                              hep_node)->urb;
+                        urb->start_frame =
+                            frame_add(last_urb->start_frame,
+                                      last_urb->number_of_packets *
+                                      last_urb->interval);
+                }
+                urbp->cnt = 0;
+                break;
+        }
+
+        /* Add the URB to the endpoint queue */
+        list_add_tail(&urbp->hep_node, &urbp->ep_data->queue);
+
+        /* If this is the only URB, kick start the controller */
+        if (!c67x00->urb_count++)
+                c67x00_ll_hpi_enable_sofeop(c67x00->sie);
+
+        c67x00_sched_kick(c67x00);
+        spin_unlock_irqrestore(&c67x00->lock, flags);
+
+        return 0;
+
+err_epdata:
+        kfree(urbp);
+err_urbp:
+        usb_hcd_unlink_urb_from_ep(hcd, urb);
+err_not_linked:
+        spin_unlock_irqrestore(&c67x00->lock, flags);
+
+        return ret;
+}
+
+int c67x00_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
+{
+        struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
+        unsigned long flags;
+        int rc;
+
+        spin_lock_irqsave(&c67x00->lock, flags);
+        rc = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (rc)
+                goto done;
+
+        c67x00_release_urb(c67x00, urb);
+        usb_hcd_unlink_urb_from_ep(hcd, urb);
+
+        spin_unlock(&c67x00->lock);
+        usb_hcd_giveback_urb(hcd, urb, status);
+        spin_lock(&c67x00->lock);
+
+        spin_unlock_irqrestore(&c67x00->lock, flags);
+
+        return 0;
+
+ done:
+        spin_unlock_irqrestore(&c67x00->lock, flags);
+        return rc;
+}
+
+/* -------------------------------------------------------------------------- */
+
+/*
+ * pre: c67x00 locked, urb unlocked
+ */
+static void
+c67x00_giveback_urb(struct c67x00_hcd *c67x00, struct urb *urb, int status)
+{
+        struct c67x00_urb_priv *urbp;
+
+        if (!urb)
+                return;
+
+        urbp = urb->hcpriv;
+        urbp->status = status;
+
+        list_del_init(&urbp->hep_node);
+
+        c67x00_release_urb(c67x00, urb);
+        usb_hcd_unlink_urb_from_ep(c67x00_hcd_to_hcd(c67x00), urb);
+        spin_unlock(&c67x00->lock);
+        usb_hcd_giveback_urb(c67x00_hcd_to_hcd(c67x00), urb, urbp->status);
+        spin_lock(&c67x00->lock);
+}
+
+/* -------------------------------------------------------------------------- */
+
+static int c67x00_claim_frame_bw(struct c67x00_hcd *c67x00, struct urb *urb,
+                                 int len, int periodic)
+{
+        struct c67x00_urb_priv *urbp = urb->hcpriv;
+        int bit_time;
+
+        /* According to the C67x00 BIOS user manual, page 3-18,19, the
+         * following calculations provide the full speed bit times for
+         * a transaction.
+         *
+         * FS(in)       = 112.5 +  9.36*BC + HOST_DELAY
+         * FS(in,iso)   =  90.5 +  9.36*BC + HOST_DELAY
+         * FS(out)      = 112.5 +  9.36*BC + HOST_DELAY
+         * FS(out,iso)  =  78.4 +  9.36*BC + HOST_DELAY
+         * LS(in)       = 802.4 + 75.78*BC + HOST_DELAY
+         * LS(out)      = 802.6 + 74.67*BC + HOST_DELAY
+         *
+         * HOST_DELAY == 106 for the c67200 and c67300.
+         */
+
+        /* make calculations in 1/100 bit times to maintain resolution */
+        if (urbp->ep_data->dev->speed == USB_SPEED_LOW) {
+                /* Low speed pipe */
+                if (usb_pipein(urb->pipe))
+                        bit_time = 80240 + 7578*len;
+                else
+                        bit_time = 80260 + 7467*len;
+        } else {
+                /* FS pipes */
+                if (usb_pipeisoc(urb->pipe))
+                        bit_time = usb_pipein(urb->pipe) ? 9050 : 7840;
+                else
+                        bit_time = 11250;
+                bit_time += 936*len;
+        }
+
+        /* Scale back down to integer bit times.  Use a host delay of 106.
+         * (this is the only place it is used) */
+        bit_time = ((bit_time+50) / 100) + 106;
+
+        if (unlikely(bit_time + c67x00->bandwidth_allocated >=
+                     c67x00->max_frame_bw))
+                return -EMSGSIZE;
+
+        if (unlikely(c67x00->next_td_addr + CY_TD_SIZE >=
+                     c67x00->td_base_addr + SIE_TD_SIZE))
+                return -EMSGSIZE;
+
+        if (unlikely(c67x00->next_buf_addr + len >=
+                     c67x00->buf_base_addr + SIE_TD_BUF_SIZE))
+                return -EMSGSIZE;
+
+        if (periodic) {
+                if (unlikely(bit_time + c67x00->periodic_bw_allocated >=
+                             MAX_PERIODIC_BW(c67x00->max_frame_bw)))
+                        return -EMSGSIZE;
+                c67x00->periodic_bw_allocated += bit_time;
+        }
+
+        c67x00->bandwidth_allocated += bit_time;
+        return 0;
+}
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * td_addr and buf_addr must be word aligned
+ */
+static int c67x00_create_td(struct c67x00_hcd *c67x00, struct urb *urb,
+                            void *data, int len, int pid, int toggle,
+                            unsigned long privdata)
+{
+        struct c67x00_td *td;
+        struct c67x00_urb_priv *urbp = urb->hcpriv;
+        const __u8 active_flag = 1, retry_cnt = 1;
+        __u8 cmd = 0;
+        int tt = 0;
+
+        if (c67x00_claim_frame_bw(c67x00, urb, len, usb_pipeisoc(urb->pipe)
+                                  || usb_pipeint(urb->pipe)))
+                return -EMSGSIZE;       /* Not really an error, but expected */
+
+        td = kzalloc(sizeof(*td), GFP_ATOMIC);
+        if (!td)
+                return -ENOMEM;
+
+        td->pipe = urb->pipe;
+        td->ep_data = urbp->ep_data;
+
+        if ((td_udev(td)->speed == USB_SPEED_LOW) &&
+            !(c67x00->low_speed_ports & (1 << urbp->port)))
+                cmd |= PREAMBLE_EN;
+
+        switch (usb_pipetype(td->pipe)) {
+        case PIPE_ISOCHRONOUS:
+                tt = TT_ISOCHRONOUS;
+                cmd |= ISO_EN;
+                break;
+        case PIPE_CONTROL:
+                tt = TT_CONTROL;
+                break;
+        case PIPE_BULK:
+                tt = TT_BULK;
+                break;
+        case PIPE_INTERRUPT:
+                tt = TT_INTERRUPT;
+                break;
+        }
+
+        if (toggle)
+                cmd |= SEQ_SEL;
+
+        cmd |= ARM_EN;
+
+        /* SW part */
+        td->td_addr = c67x00->next_td_addr;
+        c67x00->next_td_addr = c67x00->next_td_addr + CY_TD_SIZE;
+
+        /* HW part */
+        td->ly_base_addr = __cpu_to_le16(c67x00->next_buf_addr);
+        td->port_length = __cpu_to_le16((c67x00->sie->sie_num << 15) |
+                                        (urbp->port << 14) | (len & 0x3FF));
+        td->pid_ep = ((pid & 0xF) << TD_PIDEP_OFFSET) |
+            (usb_pipeendpoint(td->pipe) & 0xF);
+        td->dev_addr = usb_pipedevice(td->pipe) & 0x7F;
+        td->ctrl_reg = cmd;
+        td->status = 0;
+        td->retry_cnt = (tt << TT_OFFSET) | (active_flag << 4) | retry_cnt;
+        td->residue = 0;
+        td->next_td_addr = __cpu_to_le16(c67x00->next_td_addr);
+
+        /* SW part */
+        td->data = data;
+        td->urb = urb;
+        td->privdata = privdata;
+
+        c67x00->next_buf_addr += (len + 1) & ~0x01;     /* properly align */
+
+        list_add_tail(&td->td_list, &c67x00->td_list);
+        return 0;
+}
+
+static inline void c67x00_release_td(struct c67x00_td *td)
+{
+        list_del_init(&td->td_list);
+        kfree(td);
+}
+
+/* -------------------------------------------------------------------------- */
+
+static int c67x00_add_data_urb(struct c67x00_hcd *c67x00, struct urb *urb)
+{
+        int remaining;
+        int toggle;
+        int pid;
+        int ret = 0;
+        int maxps;
+        int need_empty;
+
+        toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe),
+                               usb_pipeout(urb->pipe));
+        remaining = urb->transfer_buffer_length - urb->actual_length;
+
+        maxps = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
+
+        need_empty = (urb->transfer_flags & URB_ZERO_PACKET) &&
+            usb_pipeout(urb->pipe) && !(remaining % maxps);
+
+        while (remaining || need_empty) {
+                int len;
+                char *td_buf;
+
+                len = (remaining > maxps) ? maxps : remaining;
+                if (!len)
+                        need_empty = 0;
+
+                pid = usb_pipeout(urb->pipe) ? USB_PID_OUT : USB_PID_IN;
+                td_buf = urb->transfer_buffer + urb->transfer_buffer_length -
+                    remaining;
+                ret = c67x00_create_td(c67x00, urb, td_buf, len, pid, toggle,
+                                       DATA_STAGE);
+                if (ret)
+                        return ret;     /* td wasn't created */
+
+                toggle ^= 1;
+                remaining -= len;
+                if (usb_pipecontrol(urb->pipe))
+                        break;
+        }
+
+        return 0;
+}
+
+/**
+ * return 0 in case more bandwidth is available, else errorcode
+ */
+static int c67x00_add_ctrl_urb(struct c67x00_hcd *c67x00, struct urb *urb)
+{
+        int ret;
+        int pid;
+
+        switch (urb->interval) {
+        default:
+        case SETUP_STAGE:
+                ret = c67x00_create_td(c67x00, urb, urb->setup_packet,
+                                       8, USB_PID_SETUP, 0, SETUP_STAGE);
+                if (ret)
+                        return ret;
+                urb->interval = SETUP_STAGE;
+                usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
+                              usb_pipeout(urb->pipe), 1);
+                break;
+        case DATA_STAGE:
+                if (urb->transfer_buffer_length) {
+                        ret = c67x00_add_data_urb(c67x00, urb);
+                        if (ret)
+                                return ret;
+                        break;
+                }               /* else fallthrough */
+        case STATUS_STAGE:
+                pid = !usb_pipeout(urb->pipe) ? USB_PID_OUT : USB_PID_IN;
+                ret = c67x00_create_td(c67x00, urb, NULL, 0, pid, 1,
+                                       STATUS_STAGE);
+                if (ret)
+                        return ret;
+                break;
+        }
+
+        return 0;
+}
+
+/*
+ * return 0 in case more bandwidth is available, else errorcode
+ */
+static int c67x00_add_int_urb(struct c67x00_hcd *c67x00, struct urb *urb)
+{
+        struct c67x00_urb_priv *urbp = urb->hcpriv;
+
+        if (frame_after_eq(c67x00->current_frame, urbp->ep_data->next_frame)) {
+                urbp->ep_data->next_frame =
+                    frame_add(urbp->ep_data->next_frame, urb->interval);
+                return c67x00_add_data_urb(c67x00, urb);
+        }
+        return 0;
+}
+
+static int c67x00_add_iso_urb(struct c67x00_hcd *c67x00, struct urb *urb)
+{
+        struct c67x00_urb_priv *urbp = urb->hcpriv;
+
+        if (frame_after_eq(c67x00->current_frame, urbp->ep_data->next_frame)) {
+                char *td_buf;
+                int len, pid, ret;
+
+                BUG_ON(urbp->cnt >= urb->number_of_packets);
+
+                td_buf = urb->transfer_buffer +
+                    urb->iso_frame_desc[urbp->cnt].offset;
+                len = urb->iso_frame_desc[urbp->cnt].length;
+                pid = usb_pipeout(urb->pipe) ? USB_PID_OUT : USB_PID_IN;
+
+                ret = c67x00_create_td(c67x00, urb, td_buf, len, pid, 0,
+                                       urbp->cnt);
+                if (ret) {
+                        printk(KERN_DEBUG "create failed: %d\n", ret);
+                        urb->iso_frame_desc[urbp->cnt].actual_length = 0;
+                        urb->iso_frame_desc[urbp->cnt].status = ret;
+                        if (urbp->cnt + 1 == urb->number_of_packets)
+                                c67x00_giveback_urb(c67x00, urb, 0);
+                }
+
+                urbp->ep_data->next_frame =
+                    frame_add(urbp->ep_data->next_frame, urb->interval);
+                urbp->cnt++;
+        }
+        return 0;
+}
+
+/* -------------------------------------------------------------------------- */
+
+static void c67x00_fill_from_list(struct c67x00_hcd *c67x00, int type,
+                                  int (*add)(struct c67x00_hcd *, struct urb *))
+{
+        struct c67x00_ep_data *ep_data;
+        struct urb *urb;
+
+        /* traverse every endpoint on the list */
+        list_for_each_entry(ep_data, &c67x00->list[type], node) {
+                if (!list_empty(&ep_data->queue)) {
+                        /* and add the first urb */
+                        /* isochronous transfer rely on this */
+                        urb = list_entry(ep_data->queue.next,
+                                         struct c67x00_urb_priv,
+                                         hep_node)->urb;
+                        add(c67x00, urb);
+                }
+        }
+}
+
+static void c67x00_fill_frame(struct c67x00_hcd *c67x00)
+{
+        struct c67x00_td *td, *ttd;
+
+        /* Check if we can proceed */
+        if (!list_empty(&c67x00->td_list)) {
+                dev_warn(c67x00_hcd_dev(c67x00),
+                         "TD list not empty! This should not happen!\n");
+                list_for_each_entry_safe(td, ttd, &c67x00->td_list, td_list) {
+                        dbg_td(c67x00, td, "Unprocessed td");
+                        c67x00_release_td(td);
+                }
+        }
+
+        /* Reinitialize variables */
+        c67x00->bandwidth_allocated = 0;
+        c67x00->periodic_bw_allocated = 0;
+
+        c67x00->next_td_addr = c67x00->td_base_addr;
+        c67x00->next_buf_addr = c67x00->buf_base_addr;
+
+        /* Fill the list */
+        c67x00_fill_from_list(c67x00, PIPE_ISOCHRONOUS, c67x00_add_iso_urb);
+        c67x00_fill_from_list(c67x00, PIPE_INTERRUPT, c67x00_add_int_urb);
+        c67x00_fill_from_list(c67x00, PIPE_CONTROL, c67x00_add_ctrl_urb);
+        c67x00_fill_from_list(c67x00, PIPE_BULK, c67x00_add_data_urb);
+}
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Get TD from C67X00
+ */
+static inline void
+c67x00_parse_td(struct c67x00_hcd *c67x00, struct c67x00_td *td)
+{
+        c67x00_ll_read_mem_le16(c67x00->sie->dev,
+                                td->td_addr, td, CY_TD_SIZE);
+
+        if (usb_pipein(td->pipe) && td_actual_bytes(td))
+                c67x00_ll_read_mem_le16(c67x00->sie->dev, td_ly_base_addr(td),
+                                        td->data, td_actual_bytes(td));
+}
+
+static int c67x00_td_to_error(struct c67x00_hcd *c67x00, struct c67x00_td *td)
+{
+        if (td->status & TD_STATUSMASK_ERR) {
+                dbg_td(c67x00, td, "ERROR_FLAG");
+                return -EILSEQ;
+        }
+        if (td->status & TD_STATUSMASK_STALL) {
+                /* dbg_td(c67x00, td, "STALL"); */
+                return -EPIPE;
+        }
+        if (td->status & TD_STATUSMASK_TMOUT) {
+                dbg_td(c67x00, td, "TIMEOUT");
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
+
+static inline int c67x00_end_of_data(struct c67x00_td *td)
+{
+        int maxps, need_empty, remaining;
+        struct urb *urb = td->urb;
+        int act_bytes;
+
+        act_bytes = td_actual_bytes(td);
+
+        if (unlikely(!act_bytes))
+                return 1;       /* This was an empty packet */
+
+        maxps = usb_maxpacket(td_udev(td), td->pipe, usb_pipeout(td->pipe));
+
+        if (unlikely(act_bytes < maxps))
+                return 1;       /* Smaller then full packet */
+
+        remaining = urb->transfer_buffer_length - urb->actual_length;
+        need_empty = (urb->transfer_flags & URB_ZERO_PACKET) &&
+            usb_pipeout(urb->pipe) && !(remaining % maxps);
+
+        if (unlikely(!remaining && !need_empty))
+                return 1;
+
+        return 0;
+}
+
+/* -------------------------------------------------------------------------- */
+
+/* Remove all td's from the list which come
+ * after last_td and are meant for the same pipe.
+ * This is used when a short packet has occured */
+static inline void c67x00_clear_pipe(struct c67x00_hcd *c67x00,
+                                     struct c67x00_td *last_td)
+{
+        struct c67x00_td *td, *tmp;
+        td = last_td;
+        tmp = last_td;
+        while (td->td_list.next != &c67x00->td_list) {
+                td = list_entry(td->td_list.next, struct c67x00_td, td_list);
+                if (td->pipe == last_td->pipe) {
+                        c67x00_release_td(td);
+                        td = tmp;
+                }
+                tmp = td;
+        }
+}
+
+/* -------------------------------------------------------------------------- */
+
+static void c67x00_handle_successful_td(struct c67x00_hcd *c67x00,
+                                        struct c67x00_td *td)
+{
+        struct urb *urb = td->urb;
+
+        if (!urb)
+                return;
+
+        urb->actual_length += td_actual_bytes(td);
+
+        switch (usb_pipetype(td->pipe)) {
+                /* isochronous tds are handled separately */
+        case PIPE_CONTROL:
+                switch (td->privdata) {
+                case SETUP_STAGE:
+                        urb->interval =
+                            urb->transfer_buffer_length ?
+                            DATA_STAGE : STATUS_STAGE;
+                        /* Don't count setup_packet with normal data: */
+                        urb->actual_length = 0;
+                        break;
+
+                case DATA_STAGE:
+                        if (c67x00_end_of_data(td)) {
+                                urb->interval = STATUS_STAGE;
+                                c67x00_clear_pipe(c67x00, td);
+                        }
+                        break;
+
+                case STATUS_STAGE:
+                        urb->interval = 0;
+                        c67x00_giveback_urb(c67x00, urb, 0);
+                        break;
+                }
+                break;
+
+        case PIPE_INTERRUPT:
+        case PIPE_BULK:
+                if (unlikely(c67x00_end_of_data(td))) {
+                        c67x00_clear_pipe(c67x00, td);
+                        c67x00_giveback_urb(c67x00, urb, 0);
+                }
+                break;
+        }
+}
+
+static void c67x00_handle_isoc(struct c67x00_hcd *c67x00, struct c67x00_td *td)
+{
+        struct urb *urb = td->urb;
+        struct c67x00_urb_priv *urbp;
+        int cnt;
+
+        if (!urb)
+                return;
+
+        urbp = urb->hcpriv;
+        cnt = td->privdata;
+
+        if (td->status & TD_ERROR_MASK)
+                urb->error_count++;
+
+        urb->iso_frame_desc[cnt].actual_length = td_actual_bytes(td);
+        urb->iso_frame_desc[cnt].status = c67x00_td_to_error(c67x00, td);
+        if (cnt + 1 == urb->number_of_packets)  /* Last packet */
+                c67x00_giveback_urb(c67x00, urb, 0);
+}
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * c67x00_check_td_list - handle tds which have been processed by the c67x00
+ * pre: current_td == 0
+ */
+static inline void c67x00_check_td_list(struct c67x00_hcd *c67x00)
+{
+        struct c67x00_td *td, *tmp;
+        struct urb *urb;
+        int ack_ok;
+        int clear_endpoint;
+
+        list_for_each_entry_safe(td, tmp, &c67x00->td_list, td_list) {
+                /* get the TD */
+                c67x00_parse_td(c67x00, td);
+                urb = td->urb;  /* urb can be NULL! */
+                ack_ok = 0;
+                clear_endpoint = 1;
+
+                /* Handle isochronous transfers separately */
+                if (usb_pipeisoc(td->pipe)) {
+                        clear_endpoint = 0;
+                        c67x00_handle_isoc(c67x00, td);
+                        goto cont;
+                }
+
+                /* When an error occurs, all td's for that pipe go into an
+                 * inactive state. This state matches successful transfers so
+                 * we must make sure not to service them. */
+                if (td->status & TD_ERROR_MASK) {
+                        c67x00_giveback_urb(c67x00, urb,
+                                            c67x00_td_to_error(c67x00, td));
+                        goto cont;
+                }
+
+                if ((td->status & TD_STATUSMASK_NAK) || !td_sequence_ok(td) ||
+                    !td_acked(td))
+                        goto cont;
+
+                /* Sequence ok and acked, don't need to fix toggle */
+                ack_ok = 1;
+
+                if (unlikely(td->status & TD_STATUSMASK_OVF)) {
+                        if (td_residue(td) & TD_RESIDUE_OVERFLOW) {
+                                /* Overflow */
+                                c67x00_giveback_urb(c67x00, urb, -EOVERFLOW);
+                                goto cont;
+                        }
+                }
+
+                clear_endpoint = 0;
+                c67x00_handle_successful_td(c67x00, td);
+
+cont:
+                if (clear_endpoint)
+                        c67x00_clear_pipe(c67x00, td);
+                if (ack_ok)
+                        usb_settoggle(td_udev(td), usb_pipeendpoint(td->pipe),
+                                      usb_pipeout(td->pipe),
+                                      !(td->ctrl_reg & SEQ_SEL));
+                /* next in list could have been removed, due to clear_pipe! */
+                tmp = list_entry(td->td_list.next, typeof(*td), td_list);
+                c67x00_release_td(td);
+        }
+}
+
+/* -------------------------------------------------------------------------- */
+
+static inline int c67x00_all_tds_processed(struct c67x00_hcd *c67x00)
+{
+        /* If all tds are processed, we can check the previous frame (if
+         * there was any) and start our next frame.
+         */
+        return !c67x00_ll_husb_get_current_td(c67x00->sie);
+}
+
+/**
+ * Send td to C67X00
+ */
+static void c67x00_send_td(struct c67x00_hcd *c67x00, struct c67x00_td *td)
+{
+        int len = td_length(td);
+
+        if (len && ((td->pid_ep & TD_PIDEPMASK_PID) != TD_PID_IN))
+                c67x00_ll_write_mem_le16(c67x00->sie->dev, td_ly_base_addr(td),
+                                         td->data, len);
+
+        c67x00_ll_write_mem_le16(c67x00->sie->dev,
+                                 td->td_addr, td, CY_TD_SIZE);
+}
+
+static void c67x00_send_frame(struct c67x00_hcd *c67x00)
+{
+        struct c67x00_td *td;
+
+        if (list_empty(&c67x00->td_list))
+                dev_warn(c67x00_hcd_dev(c67x00),
+                         "%s: td list should not be empty here!\n",
+                         __func__);
+
+        list_for_each_entry(td, &c67x00->td_list, td_list) {
+                if (td->td_list.next == &c67x00->td_list)
+                        td->next_td_addr = 0;   /* Last td in list */
+
+                c67x00_send_td(c67x00, td);
+        }
+
+        c67x00_ll_husb_set_current_td(c67x00->sie, c67x00->td_base_addr);
+}
+
+/* -------------------------------------------------------------------------- */
+
+/**
+ * c67x00_do_work - Schedulers state machine
+ */
+static void c67x00_do_work(struct c67x00_hcd *c67x00)
+{
+        spin_lock(&c67x00->lock);
+        /* Make sure all tds are processed */
+        if (!c67x00_all_tds_processed(c67x00))
+                goto out;
+
+        c67x00_check_td_list(c67x00);
+
+        /* no td's are being processed (current == 0)
+         * and all have been "checked" */
+        complete(&c67x00->endpoint_disable);
+
+        if (!list_empty(&c67x00->td_list))
+                goto out;
+
+        c67x00->current_frame = c67x00_get_current_frame_number(c67x00);
+        if (c67x00->current_frame == c67x00->last_frame)
+                goto out;       /* Don't send tds in same frame */
+        c67x00->last_frame = c67x00->current_frame;
+
+        /* If no urbs are scheduled, our work is done */
+        if (!c67x00->urb_count) {
+                c67x00_ll_hpi_disable_sofeop(c67x00->sie);
+                goto out;
+        }
+
+        c67x00_fill_frame(c67x00);
+        if (!list_empty(&c67x00->td_list))
+                /* TD's have been added to the frame */
+                c67x00_send_frame(c67x00);
+
+ out:
+        spin_unlock(&c67x00->lock);
+}
+
+/* -------------------------------------------------------------------------- */
+
+static void c67x00_sched_tasklet(unsigned long __c67x00)
+{
+        struct c67x00_hcd *c67x00 = (struct c67x00_hcd *)__c67x00;
+        c67x00_do_work(c67x00);
+}
+
+void c67x00_sched_kick(struct c67x00_hcd *c67x00)
+{
+        tasklet_hi_schedule(&c67x00->tasklet);
+}
+
+int c67x00_sched_start_scheduler(struct c67x00_hcd *c67x00)
+{
+        tasklet_init(&c67x00->tasklet, c67x00_sched_tasklet,
+                     (unsigned long)c67x00);
+        return 0;
+}
+
+void c67x00_sched_stop_scheduler(struct c67x00_hcd *c67x00)
+{
+        tasklet_kill(&c67x00->tasklet);
+}
diff --git a/drivers/usb/c67x00/c67x00.h b/drivers/usb/c67x00/c67x00.h
new file mode 100644
index 000000000000..a26e9ded0f32
--- /dev/null
+++ b/drivers/usb/c67x00/c67x00.h
@@ -0,0 +1,294 @@
+/*
+ * c67x00.h: Cypress C67X00 USB register and field definitions
+ *
+ * Copyright (C) 2006-2008 Barco N.V.
+ *    Derived from the Cypress cy7c67200/300 ezusb linux driver and
+ *    based on multiple host controller drivers inside the linux kernel.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA.
+ */
+
+#ifndef _USB_C67X00_H
+#define _USB_C67X00_H
+
+#include <linux/spinlock.h>
+#include <linux/platform_device.h>
+#include <linux/completion.h>
+#include <linux/mutex.h>
+
+/* ---------------------------------------------------------------------
+ * Cypress C67x00 register definitions
+ */
+
+/* Hardware Revision Register */
+#define HW_REV_REG              0xC004
+
+/* General USB registers */
+/* ===================== */
+
+/* USB Control Register */
+#define USB_CTL_REG(x)          ((x) ? 0xC0AA : 0xC08A)
+
+#define LOW_SPEED_PORT(x)       ((x) ? 0x0800 : 0x0400)
+#define HOST_MODE               0x0200
+#define PORT_RES_EN(x)          ((x) ? 0x0100 : 0x0080)
+#define SOF_EOP_EN(x)           ((x) ? 0x0002 : 0x0001)
+
+/* USB status register - Notice it has different content in hcd/udc mode */
+#define USB_STAT_REG(x)         ((x) ? 0xC0B0 : 0xC090)
+
+#define EP0_IRQ_FLG             0x0001
+#define EP1_IRQ_FLG             0x0002
+#define EP2_IRQ_FLG             0x0004
+#define EP3_IRQ_FLG             0x0008
+#define EP4_IRQ_FLG             0x0010
+#define EP5_IRQ_FLG             0x0020
+#define EP6_IRQ_FLG             0x0040
+#define EP7_IRQ_FLG             0x0080
+#define RESET_IRQ_FLG           0x0100
+#define SOF_EOP_IRQ_FLG         0x0200
+#define ID_IRQ_FLG              0x4000
+#define VBUS_IRQ_FLG            0x8000
+
+/* USB Host only registers */
+/* ======================= */
+
+/* Host n Control Register */
+#define HOST_CTL_REG(x)         ((x) ? 0xC0A0 : 0xC080)
+
+#define PREAMBLE_EN             0x0080  /* Preamble enable */
+#define SEQ_SEL                 0x0040  /* Data Toggle Sequence Bit Select */
+#define ISO_EN                  0x0010  /* Isochronous enable  */
+#define ARM_EN                  0x0001  /* Arm operation */
+
+/* Host n Interrupt Enable Register */
+#define HOST_IRQ_EN_REG(x)      ((x) ? 0xC0AC : 0xC08C)
+
+#define SOF_EOP_IRQ_EN          0x0200  /* SOF/EOP Interrupt Enable  */
+#define SOF_EOP_TMOUT_IRQ_EN    0x0800  /* SOF/EOP Timeout Interrupt Enable  */
+#define ID_IRQ_EN               0x4000  /* ID interrupt enable */
+#define VBUS_IRQ_EN             0x8000  /* VBUS interrupt enable */
+#define DONE_IRQ_EN             0x0001  /* Done Interrupt Enable  */
+
+/* USB status register */
+#define HOST_STAT_MASK          0x02FD
+#define PORT_CONNECT_CHANGE(x)  ((x) ? 0x0020 : 0x0010)
+#define PORT_SE0_STATUS(x)      ((x) ? 0x0008 : 0x0004)
+
+/* Host Frame Register */
+#define HOST_FRAME_REG(x)       ((x) ? 0xC0B6 : 0xC096)
+
+#define HOST_FRAME_MASK         0x07FF
+
+/* USB Peripheral only registers */
+/* ============================= */
+
+/* Device n Port Sel reg */
+#define DEVICE_N_PORT_SEL(x)    ((x) ? 0xC0A4 : 0xC084)
+
+/* Device n Interrupt Enable Register */
+#define DEVICE_N_IRQ_EN_REG(x)  ((x) ? 0xC0AC : 0xC08C)
+
+#define DEVICE_N_ENDPOINT_N_CTL_REG(dev, ep)    ((dev)                  \
+                                                 ? (0x0280 + (ep << 4)) \
+                                                 : (0x0200 + (ep << 4)))
+#define DEVICE_N_ENDPOINT_N_STAT_REG(dev, ep)   ((dev)                  \
+                                                 ? (0x0286 + (ep << 4)) \
+                                                 : (0x0206 + (ep << 4)))
+
+#define DEVICE_N_ADDRESS(dev)   ((dev) ? (0xC0AE) : (0xC08E))
+
+/* HPI registers */
+/* ============= */
+
+/* HPI Status register */
+#define SOFEOP_FLG(x)           (1 << ((x) ? 12 : 10))
+#define SIEMSG_FLG(x)           (1 << (4 + (x)))
+#define RESET_FLG(x)            ((x) ? 0x0200 : 0x0002)
+#define DONE_FLG(x)             (1 << (2 + (x)))
+#define RESUME_FLG(x)           (1 << (6 + (x)))
+#define MBX_OUT_FLG             0x0001  /* Message out available */
+#define MBX_IN_FLG              0x0100
+#define ID_FLG                  0x4000
+#define VBUS_FLG                0x8000
+
+/* Interrupt routing register */
+#define HPI_IRQ_ROUTING_REG     0x0142
+
+#define HPI_SWAP_ENABLE(x)      ((x) ? 0x0100 : 0x0001)
+#define RESET_TO_HPI_ENABLE(x)  ((x) ? 0x0200 : 0x0002)
+#define DONE_TO_HPI_ENABLE(x)   ((x) ? 0x0008 : 0x0004)
+#define RESUME_TO_HPI_ENABLE(x) ((x) ? 0x0080 : 0x0040)
+#define SOFEOP_TO_HPI_EN(x)     ((x) ? 0x2000 : 0x0800)
+#define SOFEOP_TO_CPU_EN(x)     ((x) ? 0x1000 : 0x0400)
+#define ID_TO_HPI_ENABLE        0x4000
+#define VBUS_TO_HPI_ENABLE      0x8000
+
+/* SIE msg registers */
+#define SIEMSG_REG(x)           ((x) ? 0x0148 : 0x0144)
+
+#define HUSB_TDListDone         0x1000
+
+#define SUSB_EP0_MSG            0x0001
+#define SUSB_EP1_MSG            0x0002
+#define SUSB_EP2_MSG            0x0004
+#define SUSB_EP3_MSG            0x0008
+#define SUSB_EP4_MSG            0x0010
+#define SUSB_EP5_MSG            0x0020
+#define SUSB_EP6_MSG            0x0040
+#define SUSB_EP7_MSG            0x0080
+#define SUSB_RST_MSG            0x0100
+#define SUSB_SOF_MSG            0x0200
+#define SUSB_CFG_MSG            0x0400
+#define SUSB_SUS_MSG            0x0800
+#define SUSB_ID_MSG             0x4000
+#define SUSB_VBUS_MSG           0x8000
+
+/* BIOS interrupt routines */
+
+#define SUSBx_RECEIVE_INT(x)    ((x) ? 97 : 81)
+#define SUSBx_SEND_INT(x)       ((x) ? 96 : 80)
+
+#define SUSBx_DEV_DESC_VEC(x)   ((x) ? 0x00D4 : 0x00B4)
+#define SUSBx_CONF_DESC_VEC(x)  ((x) ? 0x00D6 : 0x00B6)
+#define SUSBx_STRING_DESC_VEC(x) ((x) ? 0x00D8 : 0x00B8)
+
+#define CY_HCD_BUF_ADDR         0x500   /* Base address for host */
+#define SIE_TD_SIZE             0x200   /* size of the td list */
+#define SIE_TD_BUF_SIZE         0x400   /* size of the data buffer */
+
+#define SIE_TD_OFFSET(host)     ((host) ? (SIE_TD_SIZE+SIE_TD_BUF_SIZE) : 0)
+#define SIE_BUF_OFFSET(host)    (SIE_TD_OFFSET(host) + SIE_TD_SIZE)
+
+/* Base address of HCD + 2 x TD_SIZE + 2 x TD_BUF_SIZE */
+#define CY_UDC_REQ_HEADER_BASE  0x1100
+/* 8- byte request headers for IN/OUT transfers */
+#define CY_UDC_REQ_HEADER_SIZE  8
+
+#define CY_UDC_REQ_HEADER_ADDR(ep_num)  (CY_UDC_REQ_HEADER_BASE + \
+                                         ((ep_num) * CY_UDC_REQ_HEADER_SIZE))
+#define CY_UDC_DESC_BASE_ADDRESS        (CY_UDC_REQ_HEADER_ADDR(8))
+
+#define CY_UDC_BIOS_REPLACE_BASE        0x1800
+#define CY_UDC_REQ_BUFFER_BASE          0x2000
+#define CY_UDC_REQ_BUFFER_SIZE          0x0400
+#define CY_UDC_REQ_BUFFER_ADDR(ep_num)  (CY_UDC_REQ_BUFFER_BASE + \
+                                         ((ep_num) * CY_UDC_REQ_BUFFER_SIZE))
+
+/* ---------------------------------------------------------------------
+ * Driver data structures
+ */
+
+struct c67x00_device;
+
+/**
+ * struct c67x00_sie - Common data associated with a SIE
+ * @lock: lock to protect this struct and the associated chip registers
+ * @private_data: subdriver dependent data
+ * @irq: subdriver dependent irq handler, set NULL when not used
+ * @dev: link to common driver structure
+ * @sie_num: SIE number on chip, starting from 0
+ * @mode: SIE mode (host/peripheral/otg/not used)
+ */
+struct c67x00_sie {
+        /* Entries to be used by the subdrivers */
+        spinlock_t lock;        /* protect this structure */
+        void *private_data;
+        void (*irq) (struct c67x00_sie *sie, u16 int_status, u16 msg);
+
+        /* Read only: */
+        struct c67x00_device *dev;
+        int sie_num;
+        int mode;
+};
+
+#define sie_dev(s)      (&(s)->dev->pdev->dev)
+
+/**
+ * struct c67x00_lcp
+ */
+struct c67x00_lcp {
+        /* Internal use only */
+        struct mutex mutex;
+        struct completion msg_received;
+        u16 last_msg;
+};
+
+/*
+ * struct c67x00_hpi
+ */
+struct c67x00_hpi {
+        void __iomem *base;
+        int regstep;
+        spinlock_t lock;
+        struct c67x00_lcp lcp;
+};
+
+#define C67X00_SIES     2
+#define C67X00_PORTS    2
+
+/**
+ * struct c67x00_device - Common data associated with a c67x00 instance
+ * @hpi: hpi addresses
+ * @sie: array of sie's on this chip
+ * @pdev: platform device of instance
+ * @pdata: configuration provided by the platform
+ */
+struct c67x00_device {
+        struct c67x00_hpi hpi;
+        struct c67x00_sie sie[C67X00_SIES];
+        struct platform_device *pdev;
+        struct c67x00_platform_data *pdata;
+};
+
+/* ---------------------------------------------------------------------
+ * Low level interface functions
+ */
+
+/* Host Port Interface (HPI) functions */
+u16 c67x00_ll_hpi_status(struct c67x00_device *dev);
+void c67x00_ll_hpi_reg_init(struct c67x00_device *dev);
+void c67x00_ll_hpi_enable_sofeop(struct c67x00_sie *sie);
+void c67x00_ll_hpi_disable_sofeop(struct c67x00_sie *sie);
+
+/* General functions */
+u16 c67x00_ll_fetch_siemsg(struct c67x00_device *dev, int sie_num);
+u16 c67x00_ll_get_usb_ctl(struct c67x00_sie *sie);
+void c67x00_ll_usb_clear_status(struct c67x00_sie *sie, u16 bits);
+u16 c67x00_ll_usb_get_status(struct c67x00_sie *sie);
+void c67x00_ll_write_mem_le16(struct c67x00_device *dev, u16 addr,
+                              void *data, int len);
+void c67x00_ll_read_mem_le16(struct c67x00_device *dev, u16 addr,
+                             void *data, int len);
+
+/* Host specific functions */
+void c67x00_ll_set_husb_eot(struct c67x00_device *dev, u16 value);
+void c67x00_ll_husb_reset(struct c67x00_sie *sie, int port);
+void c67x00_ll_husb_set_current_td(struct c67x00_sie *sie, u16 addr);
+u16 c67x00_ll_husb_get_current_td(struct c67x00_sie *sie);
+u16 c67x00_ll_husb_get_frame(struct c67x00_sie *sie);
+void c67x00_ll_husb_init_host_port(struct c67x00_sie *sie);
+void c67x00_ll_husb_reset_port(struct c67x00_sie *sie, int port);
+
+/* Called by c67x00_irq to handle lcp interrupts */
+void c67x00_ll_irq(struct c67x00_device *dev, u16 int_status);
+
+/* Setup and teardown */
+void c67x00_ll_init(struct c67x00_device *dev);
+void c67x00_ll_release(struct c67x00_device *dev);
+int c67x00_ll_reset(struct c67x00_device *dev);
+
+#endif                          /* _USB_C67X00_H */
diff --git a/drivers/usb/class/Kconfig b/drivers/usb/class/Kconfig
index 3a9102d2591b..66f17ed88cb5 100644
--- a/drivers/usb/class/Kconfig
+++ b/drivers/usb/class/Kconfig
@@ -29,3 +29,14 @@ config USB_PRINTER
           To compile this driver as a module, choose M here: the
           module will be called usblp.
 
+config USB_WDM
+        tristate "USB Wireless Device Management support"
+        depends on USB
+        ---help---
+          This driver supports the WMC Device Management functionality
+          of cell phones compliant to the CDC WMC specification. You can use
+          AT commands over this device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called cdc-wdm.
+
diff --git a/drivers/usb/class/Makefile b/drivers/usb/class/Makefile
index cc391e6c2af8..535d59a30600 100644
--- a/drivers/usb/class/Makefile
+++ b/drivers/usb/class/Makefile
@@ -5,3 +5,4 @@
 
 obj-$(CONFIG_USB_ACM)           += cdc-acm.o
 obj-$(CONFIG_USB_PRINTER)       += usblp.o
+obj-$(CONFIG_USB_WDM)           += cdc-wdm.o
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index cefe7f2c6f75..c3201affa0b6 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -1125,9 +1125,6 @@ static void stop_data_traffic(struct acm *acm)
         for (i = 0; i < acm->rx_buflimit; i++)
                 usb_kill_urb(acm->ru[i].urb);
 
-        INIT_LIST_HEAD(&acm->filled_read_bufs);
-        INIT_LIST_HEAD(&acm->spare_read_bufs);
-
         tasklet_enable(&acm->urb_task);
 
         cancel_work_sync(&acm->work);
@@ -1248,6 +1245,9 @@ static struct usb_device_id acm_ids[] = {
         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
         },
+        { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
+        .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
+        },
 
         /* control interfaces with various AT-command sets */
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
new file mode 100644
index 000000000000..731db051070a
--- /dev/null
+++ b/drivers/usb/class/cdc-wdm.c
@@ -0,0 +1,740 @@
+/*
+ * cdc-wdm.c
+ *
+ * This driver supports USB CDC WCM Device Management.
+ *
+ * Copyright (c) 2007-2008 Oliver Neukum
+ *
+ * Some code taken from cdc-acm.c
+ *
+ * Released under the GPLv2.
+ *
+ * Many thanks to Carl Nordbeck
+ */
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/smp_lock.h>
+#include <linux/mutex.h>
+#include <linux/uaccess.h>
+#include <linux/bitops.h>
+#include <linux/poll.h>
+#include <linux/usb.h>
+#include <linux/usb/cdc.h>
+#include <asm/byteorder.h>
+#include <asm/unaligned.h>
+
+/*
+ * Version Information
+ */
+#define DRIVER_VERSION "v0.02"
+#define DRIVER_AUTHOR "Oliver Neukum"
+
+static struct usb_device_id wdm_ids[] = {
+        {
+                .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
+                                 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+                .bInterfaceClass = USB_CLASS_COMM,
+                .bInterfaceSubClass = USB_CDC_SUBCLASS_DMM
+        },
+        { }
+};
+
+#define WDM_MINOR_BASE  176
+
+
+#define WDM_IN_USE              1
+#define WDM_DISCONNECTING       2
+#define WDM_RESULT              3
+#define WDM_READ                4
+#define WDM_INT_STALL           5
+#define WDM_POLL_RUNNING        6
+
+
+#define WDM_MAX                 16
+
+
+static DEFINE_MUTEX(wdm_mutex);
+
+/* --- method tables --- */
+
+struct wdm_device {
+        u8                      *inbuf; /* buffer for response */
+        u8                      *outbuf; /* buffer for command */
+        u8                      *sbuf; /* buffer for status */
+        u8                      *ubuf; /* buffer for copy to user space */
+
+        struct urb              *command;
+        struct urb              *response;
+        struct urb              *validity;
+        struct usb_interface    *intf;
+        struct usb_ctrlrequest  *orq;
+        struct usb_ctrlrequest  *irq;
+        spinlock_t              iuspin;
+
+        unsigned long           flags;
+        u16                     bufsize;
+        u16                     wMaxCommand;
+        u16                     wMaxPacketSize;
+        u16                     bMaxPacketSize0;
+        __le16                  inum;
+        int                     reslength;
+        int                     length;
+        int                     read;
+        int                     count;
+        dma_addr_t              shandle;
+        dma_addr_t              ihandle;
+        struct mutex            wlock;
+        struct mutex            rlock;
+        wait_queue_head_t       wait;
+        struct work_struct      rxwork;
+        int                     werr;
+        int                     rerr;
+};
+
+static struct usb_driver wdm_driver;
+
+/* --- callbacks --- */
+static void wdm_out_callback(struct urb *urb)
+{
+        struct wdm_device *desc;
+        desc = urb->context;
+        spin_lock(&desc->iuspin);
+        desc->werr = urb->status;
+        spin_unlock(&desc->iuspin);
+        clear_bit(WDM_IN_USE, &desc->flags);
+        kfree(desc->outbuf);
+        wake_up(&desc->wait);
+}
+
+static void wdm_in_callback(struct urb *urb)
+{
+        struct wdm_device *desc = urb->context;
+        int status = urb->status;
+
+        spin_lock(&desc->iuspin);
+
+        if (status) {
+                switch (status) {
+                case -ENOENT:
+                        dev_dbg(&desc->intf->dev,
+                                "nonzero urb status received: -ENOENT");
+                        break;
+                case -ECONNRESET:
+                        dev_dbg(&desc->intf->dev,
+                                "nonzero urb status received: -ECONNRESET");
+                        break;
+                case -ESHUTDOWN:
+                        dev_dbg(&desc->intf->dev,
+                                "nonzero urb status received: -ESHUTDOWN");
+                        break;
+                case -EPIPE:
+                        err("nonzero urb status received: -EPIPE");
+                        break;
+                default:
+                        err("Unexpected error %d", status);
+                        break;
+                }
+        }
+
+        desc->rerr = status;
+        desc->reslength = urb->actual_length;
+        memmove(desc->ubuf + desc->length, desc->inbuf, desc->reslength);
+        desc->length += desc->reslength;
+        wake_up(&desc->wait);
+
+        set_bit(WDM_READ, &desc->flags);
+        spin_unlock(&desc->iuspin);
+}
+
+static void wdm_int_callback(struct urb *urb)
+{
+        int rv = 0;
+        int status = urb->status;
+        struct wdm_device *desc;
+        struct usb_ctrlrequest *req;
+        struct usb_cdc_notification *dr;
+
+        desc = urb->context;
+        req = desc->irq;
+        dr = (struct usb_cdc_notification *)desc->sbuf;
+
+        if (status) {
+                switch (status) {
+                case -ESHUTDOWN:
+                case -ENOENT:
+                case -ECONNRESET:
+                        return; /* unplug */
+                case -EPIPE:
+                        set_bit(WDM_INT_STALL, &desc->flags);
+                        err("Stall on int endpoint");
+                        goto sw; /* halt is cleared in work */
+                default:
+                        err("nonzero urb status received: %d", status);
+                        break;
+                }
+        }
+
+        if (urb->actual_length < sizeof(struct usb_cdc_notification)) {
+                err("wdm_int_callback - %d bytes", urb->actual_length);
+                goto exit;
+        }
+
+        switch (dr->bNotificationType) {
+        case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:
+                dev_dbg(&desc->intf->dev,
+                        "NOTIFY_RESPONSE_AVAILABLE received: index %d len %d",
+                        dr->wIndex, dr->wLength);
+                break;
+
+        case USB_CDC_NOTIFY_NETWORK_CONNECTION:
+
+                dev_dbg(&desc->intf->dev,
+                        "NOTIFY_NETWORK_CONNECTION %s network",
+                        dr->wValue ? "connected to" : "disconnected from");
+                goto exit;
+        default:
+                clear_bit(WDM_POLL_RUNNING, &desc->flags);
+                err("unknown notification %d received: index %d len %d",
+                        dr->bNotificationType, dr->wIndex, dr->wLength);
+                goto exit;
+        }
+
+        req->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
+        req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
+        req->wValue = 0;
+        req->wIndex = desc->inum;
+        req->wLength = cpu_to_le16(desc->bMaxPacketSize0);
+
+        usb_fill_control_urb(
+                desc->response,
+                interface_to_usbdev(desc->intf),
+                /* using common endpoint 0 */
+                usb_rcvctrlpipe(interface_to_usbdev(desc->intf), 0),
+                (unsigned char *)req,
+                desc->inbuf,
+                desc->bMaxPacketSize0,
+                wdm_in_callback,
+                desc
+        );
+        desc->response->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        spin_lock(&desc->iuspin);
+        clear_bit(WDM_READ, &desc->flags);
+        if (!test_bit(WDM_DISCONNECTING, &desc->flags)) {
+                rv = usb_submit_urb(desc->response, GFP_ATOMIC);
+                dev_dbg(&desc->intf->dev, "%s: usb_submit_urb %d",
+                        __func__, rv);
+        }
+        spin_unlock(&desc->iuspin);
+        if (rv < 0) {
+                if (rv == -EPERM)
+                        return;
+                if (rv == -ENOMEM) {
+sw:
+                        rv = schedule_work(&desc->rxwork);
+                        if (rv)
+                                err("Cannot schedule work");
+                }
+        }
+exit:
+        rv = usb_submit_urb(urb, GFP_ATOMIC);
+        if (rv)
+                err("%s - usb_submit_urb failed with result %d",
+                     __func__, rv);
+
+}
+
+static void kill_urbs(struct wdm_device *desc)
+{
+        usb_kill_urb(desc->command);
+        usb_kill_urb(desc->validity);
+        usb_kill_urb(desc->response);
+}
+
+static void free_urbs(struct wdm_device *desc)
+{
+        usb_free_urb(desc->validity);
+        usb_free_urb(desc->response);
+        usb_free_urb(desc->command);
+}
+
+static void cleanup(struct wdm_device *desc)
+{
+        usb_buffer_free(interface_to_usbdev(desc->intf),
+                        desc->wMaxPacketSize,
+                        desc->sbuf,
+                        desc->validity->transfer_dma);
+        usb_buffer_free(interface_to_usbdev(desc->intf),
+                        desc->wMaxPacketSize,
+                        desc->inbuf,
+                        desc->response->transfer_dma);
+        kfree(desc->orq);
+        kfree(desc->irq);
+        kfree(desc->ubuf);
+        free_urbs(desc);
+        kfree(desc);
+}
+
+static ssize_t wdm_write
+(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
+{
+        u8 *buf;
+        int rv = -EMSGSIZE, r, we;
+        struct wdm_device *desc = file->private_data;
+        struct usb_ctrlrequest *req;
+
+        if (count > desc->wMaxCommand)
+                count = desc->wMaxCommand;
+
+        spin_lock_irq(&desc->iuspin);
+        we = desc->werr;
+        desc->werr = 0;
+        spin_unlock_irq(&desc->iuspin);
+        if (we < 0)
+                return -EIO;
+
+        r = mutex_lock_interruptible(&desc->wlock); /* concurrent writes */
+        rv = -ERESTARTSYS;
+        if (r)
+                goto outnl;
+
+        r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
+                                                           &desc->flags));
+        if (r < 0)
+                goto out;
+
+        if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
+                rv = -ENODEV;
+                goto out;
+        }
+
+        desc->outbuf = buf = kmalloc(count, GFP_KERNEL);
+        if (!buf) {
+                rv = -ENOMEM;
+                goto out;
+        }
+
+        r = copy_from_user(buf, buffer, count);
+        if (r > 0) {
+                kfree(buf);
+                rv = -EFAULT;
+                goto out;
+        }
+
+        req = desc->orq;
+        usb_fill_control_urb(
+                desc->command,
+                interface_to_usbdev(desc->intf),
+                /* using common endpoint 0 */
+                usb_sndctrlpipe(interface_to_usbdev(desc->intf), 0),
+                (unsigned char *)req,
+                buf,
+                count,
+                wdm_out_callback,
+                desc
+        );
+
+        req->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |
+                             USB_RECIP_INTERFACE);
+        req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
+        req->wValue = 0;
+        req->wIndex = desc->inum;
+        req->wLength = cpu_to_le16(count);
+        set_bit(WDM_IN_USE, &desc->flags);
+
+        rv = usb_submit_urb(desc->command, GFP_KERNEL);
+        if (rv < 0) {
+                kfree(buf);
+                clear_bit(WDM_IN_USE, &desc->flags);
+        } else {
+                dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d",
+                        req->wIndex);
+        }
+out:
+        mutex_unlock(&desc->wlock);
+outnl:
+        return rv < 0 ? rv : count;
+}
+
+static ssize_t wdm_read
+(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
+{
+        int rv, cntr;
+        int i = 0;
+        struct wdm_device *desc = file->private_data;
+
+
+        rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
+        if (rv < 0)
+                return -ERESTARTSYS;
+
+        if (desc->length == 0) {
+                desc->read = 0;
+retry:
+                i++;
+                rv = wait_event_interruptible(desc->wait,
+                                              test_bit(WDM_READ, &desc->flags));
+
+                if (rv < 0) {
+                        rv = -ERESTARTSYS;
+                        goto err;
+                }
+
+                spin_lock_irq(&desc->iuspin);
+
+                if (desc->rerr) { /* read completed, error happened */
+                        int t = desc->rerr;
+                        desc->rerr = 0;
+                        spin_unlock_irq(&desc->iuspin);
+                        err("reading had resulted in %d", t);
+                        rv = -EIO;
+                        goto err;
+                }
+                /*
+                 * recheck whether we've lost the race
+                 * against the completion handler
+                 */
+                if (!test_bit(WDM_READ, &desc->flags)) { /* lost race */
+                        spin_unlock_irq(&desc->iuspin);
+                        goto retry;
+                }
+                if (!desc->reslength) { /* zero length read */
+                        spin_unlock_irq(&desc->iuspin);
+                        goto retry;
+                }
+                clear_bit(WDM_READ, &desc->flags);
+                spin_unlock_irq(&desc->iuspin);
+        }
+
+        cntr = count > desc->length ? desc->length : count;
+        rv = copy_to_user(buffer, desc->ubuf, cntr);
+        if (rv > 0) {
+                rv = -EFAULT;
+                goto err;
+        }
+
+        for (i = 0; i < desc->length - cntr; i++)
+                desc->ubuf[i] = desc->ubuf[i + cntr];
+
+        desc->length -= cntr;
+        rv = cntr;
+
+err:
+        mutex_unlock(&desc->rlock);
+        if (rv < 0)
+                err("wdm_read: exit error");
+        return rv;
+}
+
+static int wdm_flush(struct file *file, fl_owner_t id)
+{
+        struct wdm_device *desc = file->private_data;
+
+        wait_event(desc->wait, !test_bit(WDM_IN_USE, &desc->flags));
+        if (desc->werr < 0)
+                err("Error in flush path: %d", desc->werr);
+
+        return desc->werr;
+}
+
+static unsigned int wdm_poll(struct file *file, struct poll_table_struct *wait)
+{
+        struct wdm_device *desc = file->private_data;
+        unsigned long flags;
+        unsigned int mask = 0;
+
+        spin_lock_irqsave(&desc->iuspin, flags);
+        if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
+                mask = POLLERR;
+                spin_unlock_irqrestore(&desc->iuspin, flags);
+                goto desc_out;
+        }
+        if (test_bit(WDM_READ, &desc->flags))
+                mask = POLLIN | POLLRDNORM;
+        if (desc->rerr || desc->werr)
+                mask |= POLLERR;
+        if (!test_bit(WDM_IN_USE, &desc->flags))
+                mask |= POLLOUT | POLLWRNORM;
+        spin_unlock_irqrestore(&desc->iuspin, flags);
+
+        poll_wait(file, &desc->wait, wait);
+
+desc_out:
+        return mask;
+}
+
+static int wdm_open(struct inode *inode, struct file *file)
+{
+        int minor = iminor(inode);
+        int rv = -ENODEV;
+        struct usb_interface *intf;
+        struct wdm_device *desc;
+
+        mutex_lock(&wdm_mutex);
+        intf = usb_find_interface(&wdm_driver, minor);
+        if (!intf)
+                goto out;
+
+        desc = usb_get_intfdata(intf);
+        if (test_bit(WDM_DISCONNECTING, &desc->flags))
+                goto out;
+
+        desc->count++;
+        file->private_data = desc;
+
+        rv = usb_submit_urb(desc->validity, GFP_KERNEL);
+
+        if (rv < 0) {
+                desc->count--;
+                err("Error submitting int urb - %d", rv);
+                goto out;
+        }
+        rv = 0;
+
+out:
+        mutex_unlock(&wdm_mutex);
+        return rv;
+}
+
+static int wdm_release(struct inode *inode, struct file *file)
+{
+        struct wdm_device *desc = file->private_data;
+
+        mutex_lock(&wdm_mutex);
+        desc->count--;
+        if (!desc->count) {
+                dev_dbg(&desc->intf->dev, "wdm_release: cleanup");
+                kill_urbs(desc);
+        }
+        mutex_unlock(&wdm_mutex);
+        return 0;
+}
+
+static const struct file_operations wdm_fops = {
+        .owner =        THIS_MODULE,
+        .read =         wdm_read,
+        .write =        wdm_write,
+        .open =         wdm_open,
+        .flush =        wdm_flush,
+        .release =      wdm_release,
+        .poll =         wdm_poll
+};
+
+static struct usb_class_driver wdm_class = {
+        .name =         "cdc-wdm%d",
+        .fops =         &wdm_fops,
+        .minor_base =   WDM_MINOR_BASE,
+};
+
+/* --- error handling --- */
+static void wdm_rxwork(struct work_struct *work)
+{
+        struct wdm_device *desc = container_of(work, struct wdm_device, rxwork);
+        unsigned long flags;
+        int rv;
+
+        spin_lock_irqsave(&desc->iuspin, flags);
+        if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
+                spin_unlock_irqrestore(&desc->iuspin, flags);
+        } else {
+                spin_unlock_irqrestore(&desc->iuspin, flags);
+                rv = usb_submit_urb(desc->response, GFP_KERNEL);
+                if (rv < 0 && rv != -EPERM) {
+                        spin_lock_irqsave(&desc->iuspin, flags);
+                        if (!test_bit(WDM_DISCONNECTING, &desc->flags))
+                                schedule_work(&desc->rxwork);
+                        spin_unlock_irqrestore(&desc->iuspin, flags);
+                }
+        }
+}
+
+/* --- hotplug --- */
+
+static int wdm_probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+        int rv = -EINVAL;
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct wdm_device *desc;
+        struct usb_host_interface *iface;
+        struct usb_endpoint_descriptor *ep;
+        struct usb_cdc_dmm_desc *dmhd;
+        u8 *buffer = intf->altsetting->extra;
+        int buflen = intf->altsetting->extralen;
+        u16 maxcom = 0;
+
+        if (!buffer)
+                goto out;
+
+        while (buflen > 0) {
+                if (buffer [1] != USB_DT_CS_INTERFACE) {
+                        err("skipping garbage");
+                        goto next_desc;
+                }
+
+                switch (buffer [2]) {
+                case USB_CDC_HEADER_TYPE:
+                        break;
+                case USB_CDC_DMM_TYPE:
+                        dmhd = (struct usb_cdc_dmm_desc *)buffer;
+                        maxcom = le16_to_cpu(dmhd->wMaxCommand);
+                        dev_dbg(&intf->dev,
+                                "Finding maximum buffer length: %d", maxcom);
+                        break;
+                default:
+                        err("Ignoring extra header, type %d, length %d",
+                                buffer[2], buffer[0]);
+                        break;
+                }
+next_desc:
+                buflen -= buffer[0];
+                buffer += buffer[0];
+        }
+
+        rv = -ENOMEM;
+        desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);
+        if (!desc)
+                goto out;
+        mutex_init(&desc->wlock);
+        mutex_init(&desc->rlock);
+        spin_lock_init(&desc->iuspin);
+        init_waitqueue_head(&desc->wait);
+        desc->wMaxCommand = maxcom;
+        desc->inum = cpu_to_le16((u16)intf->cur_altsetting->desc.bInterfaceNumber);
+        desc->intf = intf;
+        INIT_WORK(&desc->rxwork, wdm_rxwork);
+
+        iface = &intf->altsetting[0];
+        ep = &iface->endpoint[0].desc;
+        if (!usb_endpoint_is_int_in(ep)) {
+                rv = -EINVAL;
+                goto err;
+        }
+
+        desc->wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);
+        desc->bMaxPacketSize0 = udev->descriptor.bMaxPacketSize0;
+
+        desc->orq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
+        if (!desc->orq)
+                goto err;
+        desc->irq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
+        if (!desc->irq)
+                goto err;
+
+        desc->validity = usb_alloc_urb(0, GFP_KERNEL);
+        if (!desc->validity)
+                goto err;
+
+        desc->response = usb_alloc_urb(0, GFP_KERNEL);
+        if (!desc->response)
+                goto err;
+
+        desc->command = usb_alloc_urb(0, GFP_KERNEL);
+        if (!desc->command)
+                goto err;
+
+        desc->ubuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
+        if (!desc->ubuf)
+                goto err;
+
+        desc->sbuf = usb_buffer_alloc(interface_to_usbdev(intf),
+                                        desc->wMaxPacketSize,
+                                        GFP_KERNEL,
+                                        &desc->validity->transfer_dma);
+        if (!desc->sbuf)
+                goto err;
+
+        desc->inbuf = usb_buffer_alloc(interface_to_usbdev(intf),
+                                        desc->bMaxPacketSize0,
+                                        GFP_KERNEL,
+                                        &desc->response->transfer_dma);
+        if (!desc->inbuf)
+                goto err2;
+
+        usb_fill_int_urb(
+                desc->validity,
+                interface_to_usbdev(intf),
+                usb_rcvintpipe(interface_to_usbdev(intf), ep->bEndpointAddress),
+                desc->sbuf,
+                desc->wMaxPacketSize,
+                wdm_int_callback,
+                desc,
+                ep->bInterval
+        );
+        desc->validity->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+        usb_set_intfdata(intf, desc);
+        rv = usb_register_dev(intf, &wdm_class);
+        dev_info(&intf->dev, "cdc-wdm%d: USB WDM device\n",
+                 intf->minor - WDM_MINOR_BASE);
+        if (rv < 0)
+                goto err;
+out:
+        return rv;
+err2:
+        usb_buffer_free(interface_to_usbdev(desc->intf),
+                        desc->wMaxPacketSize,
+                        desc->sbuf,
+                        desc->validity->transfer_dma);
+err:
+        free_urbs(desc);
+        kfree(desc->ubuf);
+        kfree(desc->orq);
+        kfree(desc->irq);
+        kfree(desc);
+        return rv;
+}
+
+static void wdm_disconnect(struct usb_interface *intf)
+{
+        struct wdm_device *desc;
+        unsigned long flags;
+
+        usb_deregister_dev(intf, &wdm_class);
+        mutex_lock(&wdm_mutex);
+        desc = usb_get_intfdata(intf);
+
+        /* the spinlock makes sure no new urbs are generated in the callbacks */
+        spin_lock_irqsave(&desc->iuspin, flags);
+        set_bit(WDM_DISCONNECTING, &desc->flags);
+        set_bit(WDM_READ, &desc->flags);
+        clear_bit(WDM_IN_USE, &desc->flags);
+        spin_unlock_irqrestore(&desc->iuspin, flags);
+        cancel_work_sync(&desc->rxwork);
+        kill_urbs(desc);
+        wake_up_all(&desc->wait);
+        if (!desc->count)
+                cleanup(desc);
+        mutex_unlock(&wdm_mutex);
+}
+
+static struct usb_driver wdm_driver = {
+        .name =         "cdc_wdm",
+        .probe =        wdm_probe,
+        .disconnect =   wdm_disconnect,
+        .id_table =     wdm_ids,
+};
+
+/* --- low level module stuff --- */
+
+static int __init wdm_init(void)
+{
+        int rv;
+
+        rv = usb_register(&wdm_driver);
+
+        return rv;
+}
+
+static void __exit wdm_exit(void)
+{
+        usb_deregister(&wdm_driver);
+}
+
+module_init(wdm_init);
+module_exit(wdm_exit);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION("USB Abstract Control Model driver for "
+                   "USB WCM Device Management");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index 99e5a68a3f12..fae55a31e26d 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -156,6 +156,10 @@ static struct attribute *ep_dev_attrs[] = {
 static struct attribute_group ep_dev_attr_grp = {
         .attrs = ep_dev_attrs,
 };
+static struct attribute_group *ep_dev_groups[] = {
+        &ep_dev_attr_grp,
+        NULL
+};
 
 static int usb_endpoint_major_init(void)
 {
@@ -298,6 +302,7 @@ int usb_create_ep_files(struct device *parent,
 
         ep_dev->desc = &endpoint->desc;
         ep_dev->udev = udev;
+        ep_dev->dev.groups = ep_dev_groups;
         ep_dev->dev.devt = MKDEV(usb_endpoint_major, ep_dev->minor);
         ep_dev->dev.class = ep_class->class;
         ep_dev->dev.parent = parent;
@@ -309,9 +314,6 @@ int usb_create_ep_files(struct device *parent,
         retval = device_register(&ep_dev->dev);
         if (retval)
                 goto error_chrdev;
-        retval = sysfs_create_group(&ep_dev->dev.kobj, &ep_dev_attr_grp);
-        if (retval)
-                goto error_group;
 
         /* create the symlink to the old-style "ep_XX" directory */
         sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress);
@@ -322,8 +324,6 @@ int usb_create_ep_files(struct device *parent,
         return retval;
 
 error_link:
-        sysfs_remove_group(&ep_dev->dev.kobj, &ep_dev_attr_grp);
-error_group:
         device_unregister(&ep_dev->dev);
         destroy_endpoint_class();
         return retval;
@@ -348,7 +348,6 @@ void usb_remove_ep_files(struct usb_host_endpoint *endpoint)
 
                 sprintf(name, "ep_%02x", endpoint->desc.bEndpointAddress);
                 sysfs_remove_link(&ep_dev->dev.parent->kobj, name);
-                sysfs_remove_group(&ep_dev->dev.kobj, &ep_dev_attr_grp);
                 device_unregister(&ep_dev->dev);
                 endpoint->ep_dev = NULL;
                 destroy_endpoint_class();
diff --git a/drivers/usb/core/generic.c b/drivers/usb/core/generic.c
index c1cb94e9f242..7e912f21fd36 100644
--- a/drivers/usb/core/generic.c
+++ b/drivers/usb/core/generic.c
@@ -155,9 +155,6 @@ static int generic_probe(struct usb_device *udev)
 {
         int err, c;
 
-        /* put device-specific files into sysfs */
-        usb_create_sysfs_dev_files(udev);
-
         /* Choose and set the configuration.  This registers the interfaces
          * with the driver core and lets interface drivers bind to them.
          */
@@ -189,8 +186,6 @@ static void generic_disconnect(struct usb_device *udev)
          * unconfigure the device */
         if (udev->actconfig)
                 usb_set_configuration(udev, -1);
-
-        usb_remove_sysfs_dev_files(udev);
 }
 
 #ifdef  CONFIG_PM
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index bf10e9c4195e..42a436478b78 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -818,12 +818,12 @@ static int usb_register_bus(struct usb_bus *bus)
         set_bit (busnum, busmap.busmap);
         bus->busnum = busnum;
 
-        bus->dev = device_create(usb_host_class, bus->controller, MKDEV(0, 0),
-                                 "usb_host%d", busnum);
+        bus->dev = device_create_drvdata(usb_host_class, bus->controller,
+                                         MKDEV(0, 0), bus,
+                                         "usb_host%d", busnum);
         result = PTR_ERR(bus->dev);
         if (IS_ERR(bus->dev))
                 goto error_create_class_dev;
-        dev_set_drvdata(bus->dev, bus);
 
         /* Add it to the local list of buses */
         list_add (&bus->bus_list, &usb_bus_list);
@@ -924,6 +924,15 @@ static int register_root_hub(struct usb_hcd *hcd)
         return retval;
 }
 
+void usb_enable_root_hub_irq (struct usb_bus *bus)
+{
+        struct usb_hcd *hcd;
+
+        hcd = container_of (bus, struct usb_hcd, self);
+        if (hcd->driver->hub_irq_enable && hcd->state != HC_STATE_HALT)
+                hcd->driver->hub_irq_enable (hcd);
+}
+
 
 /*-------------------------------------------------------------------------*/
 
@@ -1684,19 +1693,30 @@ EXPORT_SYMBOL_GPL(usb_bus_start_enum);
 irqreturn_t usb_hcd_irq (int irq, void *__hcd)
 {
         struct usb_hcd          *hcd = __hcd;
-        int                     start = hcd->state;
+        unsigned long           flags;
+        irqreturn_t             rc;
 
-        if (unlikely(start == HC_STATE_HALT ||
-            !test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
-                return IRQ_NONE;
-        if (hcd->driver->irq (hcd) == IRQ_NONE)
-                return IRQ_NONE;
+        /* IRQF_DISABLED doesn't work correctly with shared IRQs
+         * when the first handler doesn't use it.  So let's just
+         * assume it's never used.
+         */
+        local_irq_save(flags);
 
-        set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
+        if (unlikely(hcd->state == HC_STATE_HALT ||
+                     !test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) {
+                rc = IRQ_NONE;
+        } else if (hcd->driver->irq(hcd) == IRQ_NONE) {
+                rc = IRQ_NONE;
+        } else {
+                set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
+
+                if (unlikely(hcd->state == HC_STATE_HALT))
+                        usb_hc_died(hcd);
+                rc = IRQ_HANDLED;
+        }
 
-        if (unlikely(hcd->state == HC_STATE_HALT))
-                usb_hc_died (hcd);
-        return IRQ_HANDLED;
+        local_irq_restore(flags);
+        return rc;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -1860,6 +1880,13 @@ int usb_add_hcd(struct usb_hcd *hcd,
 
         /* enable irqs just before we start the controller */
         if (hcd->driver->irq) {
+
+                /* IRQF_DISABLED doesn't work as advertised when used together
+                 * with IRQF_SHARED. As usb_hcd_irq() will always disable
+                 * interrupts we can remove it here.
+                 */
+                irqflags &= ~IRQF_DISABLED;
+
                 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
                                 hcd->driver->description, hcd->self.busnum);
                 if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index 1e4b81e9eb50..b9de1569b39e 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -210,9 +210,13 @@ struct hc_driver {
         int     (*bus_suspend)(struct usb_hcd *);
         int     (*bus_resume)(struct usb_hcd *);
         int     (*start_port_reset)(struct usb_hcd *, unsigned port_num);
+        void    (*hub_irq_enable)(struct usb_hcd *);
+                /* Needed only if port-change IRQs are level-triggered */
 
                 /* force handover of high-speed port to full-speed companion */
         void    (*relinquish_port)(struct usb_hcd *, int);
+                /* has a port been handed over to a companion? */
+        int     (*port_handed_over)(struct usb_hcd *, int);
 };
 
 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 eb57fcc701d7..4cfe32a16c37 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -644,6 +644,48 @@ static void hub_stop(struct usb_hub *hub)
 
 #ifdef CONFIG_PM
 
+/* Try to identify which devices need USB-PERSIST handling */
+static int persistent_device(struct usb_device *udev)
+{
+        int i;
+        int retval;
+        struct usb_host_config *actconfig;
+
+        /* Explicitly not marked persistent? */
+        if (!udev->persist_enabled)
+                return 0;
+
+        /* No active config? */
+        actconfig = udev->actconfig;
+        if (!actconfig)
+                return 0;
+
+        /* FIXME! We should check whether it's open here or not! */
+
+        /*
+         * Check that all the interface drivers have a
+         * 'reset_resume' entrypoint
+         */
+        retval = 0;
+        for (i = 0; i < actconfig->desc.bNumInterfaces; i++) {
+                struct usb_interface *intf;
+                struct usb_driver *driver;
+
+                intf = actconfig->interface[i];
+                if (!intf->dev.driver)
+                        continue;
+                driver = to_usb_driver(intf->dev.driver);
+                if (!driver->reset_resume)
+                        return 0;
+                /*
+                 * We have at least one driver, and that one
+                 * has a reset_resume method.
+                 */
+                retval = 1;
+        }
+        return retval;
+}
+
 static void hub_restart(struct usb_hub *hub, int type)
 {
         struct usb_device *hdev = hub->hdev;
@@ -671,26 +713,19 @@ static void hub_restart(struct usb_hub *hub, int type)
                 }
 
                 /* Was the power session lost while we were suspended? */
-                switch (type) {
-                case HUB_RESET_RESUME:
-                        portstatus = 0;
-                        portchange = USB_PORT_STAT_C_CONNECTION;
-                        break;
+                status = hub_port_status(hub, port1, &portstatus, &portchange);
 
-                case HUB_RESET:
-                case HUB_RESUME:
-                        status = hub_port_status(hub, port1,
-                                        &portstatus, &portchange);
-                        break;
-                }
+                /* If the device is gone, khubd will handle it later */
+                if (status == 0 && !(portstatus & USB_PORT_STAT_CONNECTION))
+                        continue;
 
                 /* For "USB_PERSIST"-enabled children we must
                  * mark the child device for reset-resume and
                  * turn off the various status changes to prevent
                  * khubd from disconnecting it later.
                  */
-                if (udev->persist_enabled && status == 0 &&
-                                !(portstatus & USB_PORT_STAT_ENABLE)) {
+                if (status == 0 && !(portstatus & USB_PORT_STAT_ENABLE) &&
+                                persistent_device(udev)) {
                         if (portchange & USB_PORT_STAT_C_ENABLE)
                                 clear_port_feature(hub->hdev, port1,
                                                 USB_PORT_FEAT_C_ENABLE);
@@ -1326,6 +1361,12 @@ void usb_disconnect(struct usb_device **pdev)
 
         usb_unlock_device(udev);
 
+        /* Remove the device-specific files from sysfs.  This must be
+         * done with udev unlocked, because some of the attribute
+         * routines try to acquire the device lock.
+         */
+        usb_remove_sysfs_dev_files(udev);
+
         /* Unregister the device.  The device driver is responsible
          * for removing the device files from usbfs and sysfs and for
          * de-configuring the device.
@@ -1541,6 +1582,9 @@ int usb_new_device(struct usb_device *udev)
                 goto fail;
         }
 
+        /* put device-specific files into sysfs */
+        usb_create_sysfs_dev_files(udev);
+
         /* Tell the world! */
         announce_device(udev);
         return err;
@@ -2029,6 +2073,8 @@ int usb_port_resume(struct usb_device *udev)
         }
 
         clear_bit(port1, hub->busy_bits);
+        if (!hub->hdev->parent && !hub->busy_bits[0])
+                usb_enable_root_hub_irq(hub->hdev->bus);
 
         if (status == 0)
                 status = finish_port_resume(udev);
@@ -2744,7 +2790,11 @@ loop:
                 if ((status == -ENOTCONN) || (status == -ENOTSUPP))
                         break;
         }
-        dev_err(hub_dev, "unable to enumerate USB device on port %d\n", port1);
+        if (hub->hdev->parent ||
+                        !hcd->driver->port_handed_over ||
+                        !(hcd->driver->port_handed_over)(hcd, port1))
+                dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
+                                port1);
  
 done:
         hub_port_disable(hub, port1, 1);
@@ -2954,6 +3004,11 @@ static void hub_events(void)
 
                 hub->activating = 0;
 
+                /* If this is a root hub, tell the HCD it's okay to
+                 * re-enable port-change interrupts now. */
+                if (!hdev->parent && !hub->busy_bits[0])
+                        usb_enable_root_hub_irq(hdev->bus);
+
 loop_autopm:
                 /* Allow autosuspend if we're not going to run again */
                 if (list_empty(&hub->event_list))
@@ -3179,6 +3234,8 @@ int usb_reset_device(struct usb_device *udev)
                         break;
         }
         clear_bit(port1, parent_hub->busy_bits);
+        if (!parent_hdev->parent && !parent_hub->busy_bits[0])
+                usb_enable_root_hub_irq(parent_hdev->bus);
 
         if (ret < 0)
                 goto re_enumerate;
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index e819e5359d57..fe47d145255a 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -394,7 +394,9 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
         if (!io->urbs)
                 goto nomem;
 
-        urb_flags = URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT;
+        urb_flags = URB_NO_INTERRUPT;
+        if (dma)
+                urb_flags |= URB_NO_TRANSFER_DMA_MAP;
         if (usb_pipein(pipe))
                 urb_flags |= URB_SHORT_NOT_OK;
 
@@ -1605,6 +1607,7 @@ free_interfaces:
                 intf->dev.driver = NULL;
                 intf->dev.bus = &usb_bus_type;
                 intf->dev.type = &usb_if_device_type;
+                intf->dev.groups = usb_interface_groups;
                 intf->dev.dma_mask = dev->dev.dma_mask;
                 device_initialize(&intf->dev);
                 mark_quiesced(intf);
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 2e2019390290..c070b34b669d 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -47,6 +47,13 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* Edirol SD-20 */
         { USB_DEVICE(0x0582, 0x0027), .driver_info = USB_QUIRK_RESET_RESUME },
 
+        /* appletouch */
+        { USB_DEVICE(0x05ac, 0x021a), .driver_info = USB_QUIRK_RESET_RESUME },
+
+        /* Avision AV600U */
+        { USB_DEVICE(0x0638, 0x0a13), .driver_info =
+          USB_QUIRK_STRING_FETCH_255 },
+
         /* M-Systems Flash Disk Pioneers */
         { USB_DEVICE(0x08ec, 0x1000), .driver_info = USB_QUIRK_RESET_RESUME },
 
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 5b20a60de8ba..5e1f5d55bf04 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -538,6 +538,46 @@ static struct attribute_group dev_attr_grp = {
         .attrs = dev_attrs,
 };
 
+/* When modifying this list, be sure to modify dev_string_attrs_are_visible()
+ * accordingly.
+ */
+static struct attribute *dev_string_attrs[] = {
+        &dev_attr_manufacturer.attr,
+        &dev_attr_product.attr,
+        &dev_attr_serial.attr,
+        NULL
+};
+
+static mode_t dev_string_attrs_are_visible(struct kobject *kobj,
+                struct attribute *a, int n)
+{
+        struct usb_device *udev = to_usb_device(
+                        container_of(kobj, struct device, kobj));
+
+        if (a == &dev_attr_manufacturer.attr) {
+                if (udev->manufacturer == NULL)
+                        return 0;
+        } else if (a == &dev_attr_product.attr) {
+                if (udev->product == NULL)
+                        return 0;
+        } else if (a == &dev_attr_serial.attr) {
+                if (udev->serial == NULL)
+                        return 0;
+        }
+        return a->mode;
+}
+
+static struct attribute_group dev_string_attr_grp = {
+        .attrs =        dev_string_attrs,
+        .is_visible =   dev_string_attrs_are_visible,
+};
+
+struct attribute_group *usb_device_groups[] = {
+        &dev_attr_grp,
+        &dev_string_attr_grp,
+        NULL
+};
+
 /* Binary descriptors */
 
 static ssize_t
@@ -548,35 +588,33 @@ read_descriptors(struct kobject *kobj, struct bin_attribute *attr,
                         container_of(kobj, struct device, kobj));
         size_t nleft = count;
         size_t srclen, n;
+        int cfgno;
+        void *src;
 
-        usb_lock_device(udev);
-
-        /* The binary attribute begins with the device descriptor */
-        srclen = sizeof(struct usb_device_descriptor);
-        if (off < srclen) {
-                n = min_t(size_t, nleft, srclen - off);
-                memcpy(buf, off + (char *) &udev->descriptor, n);
-                nleft -= n;
-                buf += n;
-                off = 0;
-        } else {
-                off -= srclen;
-        }
-
-        /* Then follows the raw descriptor entry for the current
-         * configuration (config plus subsidiary descriptors).
+        /* The binary attribute begins with the device descriptor.
+         * Following that are the raw descriptor entries for all the
+         * configurations (config plus subsidiary descriptors).
          */
-        if (udev->actconfig) {
-                int cfgno = udev->actconfig - udev->config;
-
-                srclen = __le16_to_cpu(udev->actconfig->desc.wTotalLength);
+        for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
+                        nleft > 0; ++cfgno) {
+                if (cfgno < 0) {
+                        src = &udev->descriptor;
+                        srclen = sizeof(struct usb_device_descriptor);
+                } else {
+                        src = udev->rawdescriptors[cfgno];
+                        srclen = __le16_to_cpu(udev->config[cfgno].desc.
+                                        wTotalLength);
+                }
                 if (off < srclen) {
-                        n = min_t(size_t, nleft, srclen - off);
-                        memcpy(buf, off + udev->rawdescriptors[cfgno], n);
+                        n = min(nleft, srclen - (size_t) off);
+                        memcpy(buf, src + off, n);
                         nleft -= n;
+                        buf += n;
+                        off = 0;
+                } else {
+                        off -= srclen;
                 }
         }
-        usb_unlock_device(udev);
         return count - nleft;
 }
 
@@ -591,10 +629,9 @@ int usb_create_sysfs_dev_files(struct usb_device *udev)
         struct device *dev = &udev->dev;
         int retval;
 
-        retval = sysfs_create_group(&dev->kobj, &dev_attr_grp);
-        if (retval)
-                return retval;
-
+        /* Unforunately these attributes cannot be created before
+         * the uevent is broadcast.
+         */
         retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
         if (retval)
                 goto error;
@@ -607,21 +644,6 @@ int usb_create_sysfs_dev_files(struct usb_device *udev)
         if (retval)
                 goto error;
 
-        if (udev->manufacturer) {
-                retval = device_create_file(dev, &dev_attr_manufacturer);
-                if (retval)
-                        goto error;
-        }
-        if (udev->product) {
-                retval = device_create_file(dev, &dev_attr_product);
-                if (retval)
-                        goto error;
-        }
-        if (udev->serial) {
-                retval = device_create_file(dev, &dev_attr_serial);
-                if (retval)
-                        goto error;
-        }
         retval = usb_create_ep_files(dev, &udev->ep0, udev);
         if (retval)
                 goto error;
@@ -636,13 +658,9 @@ void usb_remove_sysfs_dev_files(struct usb_device *udev)
         struct device *dev = &udev->dev;
 
         usb_remove_ep_files(&udev->ep0);
-        device_remove_file(dev, &dev_attr_manufacturer);
-        device_remove_file(dev, &dev_attr_product);
-        device_remove_file(dev, &dev_attr_serial);
         remove_power_attributes(dev);
         remove_persist_attributes(dev);
         device_remove_bin_file(dev, &dev_bin_attr_descriptors);
-        sysfs_remove_group(&dev->kobj, &dev_attr_grp);
 }
 
 /* Interface Accociation Descriptor fields */
@@ -688,17 +706,15 @@ static ssize_t show_interface_string(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
         struct usb_interface *intf;
-        struct usb_device *udev;
-        int len;
+        char *string;
 
         intf = to_usb_interface(dev);
-        udev = interface_to_usbdev(intf);
-        len = snprintf(buf, 256, "%s", intf->cur_altsetting->string);
-        if (len < 0)
+        string = intf->cur_altsetting->string;
+        barrier();              /* The altsetting might change! */
+
+        if (!string)
                 return 0;
-        buf[len] = '\n';
-        buf[len+1] = 0;
-        return len+1;
+        return sprintf(buf, "%s\n", string);
 }
 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL);
 
@@ -727,18 +743,6 @@ static ssize_t show_modalias(struct device *dev,
 }
 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 
-static struct attribute *intf_assoc_attrs[] = {
-        &dev_attr_iad_bFirstInterface.attr,
-        &dev_attr_iad_bInterfaceCount.attr,
-        &dev_attr_iad_bFunctionClass.attr,
-        &dev_attr_iad_bFunctionSubClass.attr,
-        &dev_attr_iad_bFunctionProtocol.attr,
-        NULL,
-};
-static struct attribute_group intf_assoc_attr_grp = {
-        .attrs = intf_assoc_attrs,
-};
-
 static struct attribute *intf_attrs[] = {
         &dev_attr_bInterfaceNumber.attr,
         &dev_attr_bAlternateSetting.attr,
@@ -753,6 +757,37 @@ static struct attribute_group intf_attr_grp = {
         .attrs = intf_attrs,
 };
 
+static struct attribute *intf_assoc_attrs[] = {
+        &dev_attr_iad_bFirstInterface.attr,
+        &dev_attr_iad_bInterfaceCount.attr,
+        &dev_attr_iad_bFunctionClass.attr,
+        &dev_attr_iad_bFunctionSubClass.attr,
+        &dev_attr_iad_bFunctionProtocol.attr,
+        NULL,
+};
+
+static mode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
+                struct attribute *a, int n)
+{
+        struct usb_interface *intf = to_usb_interface(
+                        container_of(kobj, struct device, kobj));
+
+        if (intf->intf_assoc == NULL)
+                return 0;
+        return a->mode;
+}
+
+static struct attribute_group intf_assoc_attr_grp = {
+        .attrs =        intf_assoc_attrs,
+        .is_visible =   intf_assoc_attrs_are_visible,
+};
+
+struct attribute_group *usb_interface_groups[] = {
+        &intf_attr_grp,
+        &intf_assoc_attr_grp,
+        NULL
+};
+
 static inline void usb_create_intf_ep_files(struct usb_interface *intf,
                 struct usb_device *udev)
 {
@@ -777,23 +812,21 @@ static inline void usb_remove_intf_ep_files(struct usb_interface *intf)
 
 int usb_create_sysfs_intf_files(struct usb_interface *intf)
 {
-        struct device *dev = &intf->dev;
         struct usb_device *udev = interface_to_usbdev(intf);
         struct usb_host_interface *alt = intf->cur_altsetting;
         int retval;
 
         if (intf->sysfs_files_created)
                 return 0;
-        retval = sysfs_create_group(&dev->kobj, &intf_attr_grp);
-        if (retval)
-                return retval;
 
+        /* The interface string may be present in some altsettings
+         * and missing in others.  Hence its attribute cannot be created
+         * before the uevent is broadcast.
+         */
         if (alt->string == NULL)
                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
         if (alt->string)
-                retval = device_create_file(dev, &dev_attr_interface);
-        if (intf->intf_assoc)
-                retval = sysfs_create_group(&dev->kobj, &intf_assoc_attr_grp);
+                retval = device_create_file(&intf->dev, &dev_attr_interface);
         usb_create_intf_ep_files(intf, udev);
         intf->sysfs_files_created = 1;
         return 0;
@@ -807,7 +840,5 @@ void usb_remove_sysfs_intf_files(struct usb_interface *intf)
                 return;
         usb_remove_intf_ep_files(intf);
         device_remove_file(dev, &dev_attr_interface);
-        sysfs_remove_group(&dev->kobj, &intf_attr_grp);
-        sysfs_remove_group(&intf->dev.kobj, &intf_assoc_attr_grp);
         intf->sysfs_files_created = 0;
 }
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 1f0db51190cc..325774375837 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -291,6 +291,7 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
         device_initialize(&dev->dev);
         dev->dev.bus = &usb_bus_type;
         dev->dev.type = &usb_device_type;
+        dev->dev.groups = usb_device_groups;
         dev->dev.dma_mask = bus->controller->dma_mask;
         set_dev_node(&dev->dev, dev_to_node(bus->controller));
         dev->state = USB_STATE_ATTACHED;
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 1bf8ccb9c58d..1a8bc21c335e 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -130,6 +130,10 @@ static inline int is_active(const struct usb_interface *f)
 /* for labeling diagnostics */
 extern const char *usbcore_name;
 
+/* sysfs stuff */
+extern struct attribute_group *usb_device_groups[];
+extern struct attribute_group *usb_interface_groups[];
+
 /* usbfs stuff */
 extern struct mutex usbfs_mutex;
 extern struct usb_driver usbfs_driver;
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index f7b54651dd42..6e784d2db423 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -231,6 +231,26 @@ config SUPERH_BUILT_IN_M66592
            However, this problem is improved if change a value of
            NET_IP_ALIGN to 4.
 
+config USB_GADGET_PXA27X
+        boolean "PXA 27x"
+        depends on ARCH_PXA && PXA27x
+        help
+           Intel's PXA 27x series XScale ARM v5TE processors include
+           an integrated full speed USB 1.1 device controller.
+
+           It has up to 23 endpoints, as well as endpoint zero (for
+           control transfers).
+
+           Say "y" to link the driver statically, or "m" to build a
+           dynamically linked module called "pxa27x_udc" and force all
+           gadget drivers to also be dynamically linked.
+
+config USB_PXA27X
+        tristate
+        depends on USB_GADGET_PXA27X
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 config USB_GADGET_GOKU
         boolean "Toshiba TC86C001 'Goku-S'"
         depends on PCI
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index c3aab80b6c76..12357255d740 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_USB_DUMMY_HCD)	+= dummy_hcd.o
 obj-$(CONFIG_USB_NET2280)       += net2280.o
 obj-$(CONFIG_USB_AMD5536UDC)    += amd5536udc.o
 obj-$(CONFIG_USB_PXA2XX)        += pxa2xx_udc.o
+obj-$(CONFIG_USB_PXA27X)        += pxa27x_udc.o
 obj-$(CONFIG_USB_GOKU)          += goku_udc.o
 obj-$(CONFIG_USB_OMAP)          += omap_udc.o
 obj-$(CONFIG_USB_LH7A40X)       += lh7a40x_udc.o
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index ce337cb5d137..f261d2a9a5f0 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -3251,7 +3251,7 @@ static int udc_pci_probe(
         /* pci setup */
         if (pci_enable_device(pdev) < 0) {
                 kfree(dev);
-                dev = 0;
+                dev = NULL;
                 retval = -ENODEV;
                 goto finished;
         }
@@ -3264,7 +3264,7 @@ static int udc_pci_probe(
         if (!request_mem_region(resource, len, name)) {
                 dev_dbg(&pdev->dev, "pci device used already\n");
                 kfree(dev);
-                dev = 0;
+                dev = NULL;
                 retval = -EBUSY;
                 goto finished;
         }
@@ -3274,7 +3274,7 @@ static int udc_pci_probe(
         if (dev->virt_addr == NULL) {
                 dev_dbg(&pdev->dev, "start address cannot be mapped\n");
                 kfree(dev);
-                dev = 0;
+                dev = NULL;
                 retval = -EFAULT;
                 goto finished;
         }
@@ -3282,7 +3282,7 @@ static int udc_pci_probe(
         if (!pdev->irq) {
                 dev_err(&dev->pdev->dev, "irq not set\n");
                 kfree(dev);
-                dev = 0;
+                dev = NULL;
                 retval = -ENODEV;
                 goto finished;
         }
@@ -3290,7 +3290,7 @@ static int udc_pci_probe(
         if (request_irq(pdev->irq, udc_irq, IRQF_SHARED, name, dev) != 0) {
                 dev_dbg(&dev->pdev->dev, "request_irq(%d) fail\n", pdev->irq);
                 kfree(dev);
-                dev = 0;
+                dev = NULL;
                 retval = -EBUSY;
                 goto finished;
         }
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index e756023362c2..07e5a0b5dcda 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -649,7 +649,13 @@ static int usba_ep_disable(struct usb_ep *_ep)
 
         if (!ep->desc) {
                 spin_unlock_irqrestore(&udc->lock, flags);
-                DBG(DBG_ERR, "ep_disable: %s not enabled\n", ep->ep.name);
+                /* REVISIT because this driver disables endpoints in
+                 * reset_all_endpoints() before calling disconnect(),
+                 * most gadget drivers would trigger this non-error ...
+                 */
+                if (udc->gadget.speed != USB_SPEED_UNKNOWN)
+                        DBG(DBG_ERR, "ep_disable: %s not enabled\n",
+                                        ep->ep.name);
                 return -EINVAL;
         }
         ep->desc = NULL;
@@ -1032,8 +1038,6 @@ static struct usba_udc the_udc = {
                         .release        = nop_release,
                 },
         },
-
-        .lock   = SPIN_LOCK_UNLOCKED,
 };
 
 /*
@@ -1052,6 +1056,12 @@ static void reset_all_endpoints(struct usba_udc *udc)
                 request_complete(ep, req, -ECONNRESET);
         }
 
+        /* NOTE:  normally, the next call to the gadget driver is in
+         * charge of disabling endpoints... usually disconnect().
+         * The exception would be entering a high speed test mode.
+         *
+         * FIXME remove this code ... and retest thoroughly.
+         */
         list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
                 if (ep->desc) {
                         spin_unlock(&udc->lock);
@@ -1219,7 +1229,7 @@ static inline bool feature_is_ep_halt(struct usb_ctrlrequest *crq)
 static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep,
                 struct usb_ctrlrequest *crq)
 {
-        int retval = 0;;
+        int retval = 0;
 
         switch (crq->bRequest) {
         case USB_REQ_GET_STATUS: {
@@ -1693,6 +1703,14 @@ static irqreturn_t usba_udc_irq(int irq, void *devid)
                 usba_writel(udc, INT_CLR, USBA_END_OF_RESET);
                 reset_all_endpoints(udc);
 
+                if (udc->gadget.speed != USB_SPEED_UNKNOWN
+                                && udc->driver->disconnect) {
+                        udc->gadget.speed = USB_SPEED_UNKNOWN;
+                        spin_unlock(&udc->lock);
+                        udc->driver->disconnect(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+
                 if (status & USBA_HIGH_SPEED) {
                         DBG(DBG_BUS, "High-speed bus reset detected\n");
                         udc->gadget.speed = USB_SPEED_HIGH;
@@ -1716,9 +1734,13 @@ static irqreturn_t usba_udc_irq(int irq, void *devid)
                                 | USBA_DET_SUSPEND
                                 | USBA_END_OF_RESUME));
 
+                /*
+                 * Unclear why we hit this irregularly, e.g. in usbtest,
+                 * but it's clearly harmless...
+                 */
                 if (!(usba_ep_readl(ep0, CFG) & USBA_EPT_MAPPED))
-                        dev_warn(&udc->pdev->dev,
-                                 "WARNING: EP0 configuration is invalid!\n");
+                        dev_dbg(&udc->pdev->dev,
+                                 "ODD: EP0 configuration is invalid!\n");
         }
 
         spin_unlock(&udc->lock);
@@ -1751,9 +1773,11 @@ static irqreturn_t usba_vbus_irq(int irq, void *devid)
                         reset_all_endpoints(udc);
                         toggle_bias(0);
                         usba_writel(udc, CTRL, USBA_DISABLE_MASK);
-                        spin_unlock(&udc->lock);
-                        udc->driver->disconnect(&udc->gadget);
-                        spin_lock(&udc->lock);
+                        if (udc->driver->disconnect) {
+                                spin_unlock(&udc->lock);
+                                udc->driver->disconnect(&udc->gadget);
+                                spin_lock(&udc->lock);
+                        }
                 }
                 udc->vbus_prev = vbus;
         }
@@ -1825,7 +1849,7 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 
         if (!udc->pdev)
                 return -ENODEV;
-        if (driver != udc->driver)
+        if (driver != udc->driver || !driver->unbind)
                 return -EINVAL;
 
         if (udc->vbus_pin != -1)
@@ -1840,6 +1864,9 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         toggle_bias(0);
         usba_writel(udc, CTRL, USBA_DISABLE_MASK);
 
+        if (udc->driver->disconnect)
+                udc->driver->disconnect(&udc->gadget);
+
         driver->unbind(&udc->gadget);
         udc->gadget.dev.driver = NULL;
         udc->driver = NULL;
@@ -1879,6 +1906,7 @@ static int __init usba_udc_probe(struct platform_device *pdev)
                 goto err_get_hclk;
         }
 
+        spin_lock_init(&udc->lock);
         udc->pdev = pdev;
         udc->pclk = pclk;
         udc->hclk = hclk;
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index bb93bdd76593..8d61ea67a817 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -235,10 +235,6 @@ MODULE_PARM_DESC(host_addr, "Host Ethernet Address");
 #define DEV_CONFIG_CDC
 #endif
 
-#ifdef CONFIG_USB_GADGET_PXA27X
-#define DEV_CONFIG_CDC
-#endif
-
 #ifdef CONFIG_USB_GADGET_S3C2410
 #define DEV_CONFIG_CDC
 #endif
@@ -270,6 +266,10 @@ MODULE_PARM_DESC(host_addr, "Host Ethernet Address");
 #define DEV_CONFIG_SUBSET
 #endif
 
+#ifdef CONFIG_USB_GADGET_PXA27X
+#define DEV_CONFIG_SUBSET
+#endif
+
 #ifdef CONFIG_USB_GADGET_SUPERH
 #define DEV_CONFIG_SUBSET
 #endif
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index bf3f946fd455..47bb9f09a1aa 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -2307,6 +2307,29 @@ static int halt_bulk_in_endpoint(struct fsg_dev *fsg)
         return rc;
 }
 
+static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
+{
+        int     rc;
+
+        DBG(fsg, "bulk-in set wedge\n");
+        rc = usb_ep_set_wedge(fsg->bulk_in);
+        if (rc == -EAGAIN)
+                VDBG(fsg, "delayed bulk-in endpoint wedge\n");
+        while (rc != 0) {
+                if (rc != -EAGAIN) {
+                        WARN(fsg, "usb_ep_set_wedge -> %d\n", rc);
+                        rc = 0;
+                        break;
+                }
+
+                /* Wait for a short time and then try again */
+                if (msleep_interruptible(100) != 0)
+                        return -EINTR;
+                rc = usb_ep_set_wedge(fsg->bulk_in);
+        }
+        return rc;
+}
+
 static int pad_with_zeros(struct fsg_dev *fsg)
 {
         struct fsg_buffhd       *bh = fsg->next_buffhd_to_fill;
@@ -2957,7 +2980,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
                  * We aren't required to halt the OUT endpoint; instead
                  * we can simply accept and discard any data received
                  * until the next reset. */
-                halt_bulk_in_endpoint(fsg);
+                wedge_bulk_in_endpoint(fsg);
                 set_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
                 return -EINVAL;
         }
diff --git a/drivers/usb/gadget/fsl_usb2_udc.c b/drivers/usb/gadget/fsl_usb2_udc.c
index 651b82701394..18687543d7fa 100644
--- a/drivers/usb/gadget/fsl_usb2_udc.c
+++ b/drivers/usb/gadget/fsl_usb2_udc.c
@@ -1627,7 +1627,9 @@ static int reset_queues(struct fsl_udc *udc)
                 udc_reset_ep_queue(udc, pipe);
 
         /* report disconnect; the driver is already quiesced */
+        spin_unlock(&udc->lock);
         udc->driver->disconnect(&udc->gadget);
+        spin_lock(&udc->lock);
 
         return 0;
 }
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
new file mode 100644
index 000000000000..e02bfd4df3a6
--- /dev/null
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -0,0 +1,2404 @@
+/*
+ * Handles the Intel 27x USB Device Controller (UDC)
+ *
+ * Inspired by original driver by Frank Becker, David Brownell, and others.
+ * Copyright (C) 2008 Robert Jarzmik
+ *
+ * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/version.h>
+#include <linux/errno.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/proc_fs.h>
+#include <linux/clk.h>
+#include <linux/irq.h>
+
+#include <asm/byteorder.h>
+#include <asm/hardware.h>
+
+#include <linux/usb.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+#include <asm/arch/udc.h>
+
+#include "pxa27x_udc.h"
+
+/*
+ * This driver handles the USB Device Controller (UDC) in Intel's PXA 27x
+ * series processors.
+ *
+ * Such controller drivers work with a gadget driver.  The gadget driver
+ * returns descriptors, implements configuration and data protocols used
+ * by the host to interact with this device, and allocates endpoints to
+ * the different protocol interfaces.  The controller driver virtualizes
+ * usb hardware so that the gadget drivers will be more portable.
+ *
+ * This UDC hardware wants to implement a bit too much USB protocol. The
+ * biggest issues are:  that the endpoints have to be set up before the
+ * controller can be enabled (minor, and not uncommon); and each endpoint
+ * can only have one configuration, interface and alternative interface
+ * number (major, and very unusual). Once set up, these cannot be changed
+ * without a controller reset.
+ *
+ * The workaround is to setup all combinations necessary for the gadgets which
+ * will work with this driver. This is done in pxa_udc structure, statically.
+ * See pxa_udc, udc_usb_ep versus pxa_ep, and matching function find_pxa_ep.
+ * (You could modify this if needed.  Some drivers have a "fifo_mode" module
+ * parameter to facilitate such changes.)
+ *
+ * The combinations have been tested with these gadgets :
+ *  - zero gadget
+ *  - file storage gadget
+ *  - ether gadget
+ *
+ * The driver doesn't use DMA, only IO access and IRQ callbacks. No use is
+ * made of UDC's double buffering either. USB "On-The-Go" is not implemented.
+ *
+ * All the requests are handled the same way :
+ *  - the drivers tries to handle the request directly to the IO
+ *  - if the IO fifo is not big enough, the remaining is send/received in
+ *    interrupt handling.
+ */
+
+#define DRIVER_VERSION  "2008-04-18"
+#define DRIVER_DESC     "PXA 27x USB Device Controller driver"
+
+static const char driver_name[] = "pxa27x_udc";
+static struct pxa_udc *the_controller;
+
+static void handle_ep(struct pxa_ep *ep);
+
+/*
+ * Debug filesystem
+ */
+#ifdef CONFIG_USB_GADGET_DEBUG_FS
+
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/seq_file.h>
+
+static int state_dbg_show(struct seq_file *s, void *p)
+{
+        struct pxa_udc *udc = s->private;
+        int pos = 0, ret;
+        u32 tmp;
+
+        ret = -ENODEV;
+        if (!udc->driver)
+                goto out;
+
+        /* basic device status */
+        pos += seq_printf(s, DRIVER_DESC "\n"
+                         "%s version: %s\nGadget driver: %s\n",
+                         driver_name, DRIVER_VERSION,
+                         udc->driver ? udc->driver->driver.name : "(none)");
+
+        tmp = udc_readl(udc, UDCCR);
+        pos += seq_printf(s,
+                         "udccr=0x%0x(%s%s%s%s%s%s%s%s%s%s), "
+                         "con=%d,inter=%d,altinter=%d\n", tmp,
+                         (tmp & UDCCR_OEN) ? " oen":"",
+                         (tmp & UDCCR_AALTHNP) ? " aalthnp":"",
+                         (tmp & UDCCR_AHNP) ? " rem" : "",
+                         (tmp & UDCCR_BHNP) ? " rstir" : "",
+                         (tmp & UDCCR_DWRE) ? " dwre" : "",
+                         (tmp & UDCCR_SMAC) ? " smac" : "",
+                         (tmp & UDCCR_EMCE) ? " emce" : "",
+                         (tmp & UDCCR_UDR) ? " udr" : "",
+                         (tmp & UDCCR_UDA) ? " uda" : "",
+                         (tmp & UDCCR_UDE) ? " ude" : "",
+                         (tmp & UDCCR_ACN) >> UDCCR_ACN_S,
+                         (tmp & UDCCR_AIN) >> UDCCR_AIN_S,
+                         (tmp & UDCCR_AAISN) >> UDCCR_AAISN_S);
+        /* registers for device and ep0 */
+        pos += seq_printf(s, "udcicr0=0x%08x udcicr1=0x%08x\n",
+                        udc_readl(udc, UDCICR0), udc_readl(udc, UDCICR1));
+        pos += seq_printf(s, "udcisr0=0x%08x udcisr1=0x%08x\n",
+                        udc_readl(udc, UDCISR0), udc_readl(udc, UDCISR1));
+        pos += seq_printf(s, "udcfnr=%d\n", udc_readl(udc, UDCFNR));
+        pos += seq_printf(s, "irqs: reset=%lu, suspend=%lu, resume=%lu, "
+                        "reconfig=%lu\n",
+                        udc->stats.irqs_reset, udc->stats.irqs_suspend,
+                        udc->stats.irqs_resume, udc->stats.irqs_reconfig);
+
+        ret = 0;
+out:
+        return ret;
+}
+
+static int queues_dbg_show(struct seq_file *s, void *p)
+{
+        struct pxa_udc *udc = s->private;
+        struct pxa_ep *ep;
+        struct pxa27x_request *req;
+        int pos = 0, i, maxpkt, ret;
+
+        ret = -ENODEV;
+        if (!udc->driver)
+                goto out;
+
+        /* dump endpoint queues */
+        for (i = 0; i < NR_PXA_ENDPOINTS; i++) {
+                ep = &udc->pxa_ep[i];
+                maxpkt = ep->fifo_size;
+                pos += seq_printf(s,  "%-12s max_pkt=%d %s\n",
+                                EPNAME(ep), maxpkt, "pio");
+
+                if (list_empty(&ep->queue)) {
+                        pos += seq_printf(s, "\t(nothing queued)\n");
+                        continue;
+                }
+
+                list_for_each_entry(req, &ep->queue, queue) {
+                        pos += seq_printf(s,  "\treq %p len %d/%d buf %p\n",
+                                        &req->req, req->req.actual,
+                                        req->req.length, req->req.buf);
+                }
+        }
+
+        ret = 0;
+out:
+        return ret;
+}
+
+static int eps_dbg_show(struct seq_file *s, void *p)
+{
+        struct pxa_udc *udc = s->private;
+        struct pxa_ep *ep;
+        int pos = 0, i, ret;
+        u32 tmp;
+
+        ret = -ENODEV;
+        if (!udc->driver)
+                goto out;
+
+        ep = &udc->pxa_ep[0];
+        tmp = udc_ep_readl(ep, UDCCSR);
+        pos += seq_printf(s, "udccsr0=0x%03x(%s%s%s%s%s%s%s)\n", tmp,
+                         (tmp & UDCCSR0_SA) ? " sa" : "",
+                         (tmp & UDCCSR0_RNE) ? " rne" : "",
+                         (tmp & UDCCSR0_FST) ? " fst" : "",
+                         (tmp & UDCCSR0_SST) ? " sst" : "",
+                         (tmp & UDCCSR0_DME) ? " dme" : "",
+                         (tmp & UDCCSR0_IPR) ? " ipr" : "",
+                         (tmp & UDCCSR0_OPC) ? " opc" : "");
+        for (i = 0; i < NR_PXA_ENDPOINTS; i++) {
+                ep = &udc->pxa_ep[i];
+                tmp = i? udc_ep_readl(ep, UDCCR) : udc_readl(udc, UDCCR);
+                pos += seq_printf(s, "%-12s: "
+                                "IN %lu(%lu reqs), OUT %lu(%lu reqs), "
+                                "irqs=%lu, udccr=0x%08x, udccsr=0x%03x, "
+                                "udcbcr=%d\n",
+                                EPNAME(ep),
+                                ep->stats.in_bytes, ep->stats.in_ops,
+                                ep->stats.out_bytes, ep->stats.out_ops,
+                                ep->stats.irqs,
+                                tmp, udc_ep_readl(ep, UDCCSR),
+                                udc_ep_readl(ep, UDCBCR));
+        }
+
+        ret = 0;
+out:
+        return ret;
+}
+
+static int eps_dbg_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, eps_dbg_show, inode->i_private);
+}
+
+static int queues_dbg_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, queues_dbg_show, inode->i_private);
+}
+
+static int state_dbg_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, state_dbg_show, inode->i_private);
+}
+
+static const struct file_operations state_dbg_fops = {
+        .owner          = THIS_MODULE,
+        .open           = state_dbg_open,
+        .llseek         = seq_lseek,
+        .read           = seq_read,
+        .release        = single_release,
+};
+
+static const struct file_operations queues_dbg_fops = {
+        .owner          = THIS_MODULE,
+        .open           = queues_dbg_open,
+        .llseek         = seq_lseek,
+        .read           = seq_read,
+        .release        = single_release,
+};
+
+static const struct file_operations eps_dbg_fops = {
+        .owner          = THIS_MODULE,
+        .open           = eps_dbg_open,
+        .llseek         = seq_lseek,
+        .read           = seq_read,
+        .release        = single_release,
+};
+
+static void pxa_init_debugfs(struct pxa_udc *udc)
+{
+        struct dentry *root, *state, *queues, *eps;
+
+        root = debugfs_create_dir(udc->gadget.name, NULL);
+        if (IS_ERR(root) || !root)
+                goto err_root;
+
+        state = debugfs_create_file("udcstate", 0400, root, udc,
+                        &state_dbg_fops);
+        if (!state)
+                goto err_state;
+        queues = debugfs_create_file("queues", 0400, root, udc,
+                        &queues_dbg_fops);
+        if (!queues)
+                goto err_queues;
+        eps = debugfs_create_file("epstate", 0400, root, udc,
+                        &eps_dbg_fops);
+        if (!queues)
+                goto err_eps;
+
+        udc->debugfs_root = root;
+        udc->debugfs_state = state;
+        udc->debugfs_queues = queues;
+        udc->debugfs_eps = eps;
+        return;
+err_eps:
+        debugfs_remove(eps);
+err_queues:
+        debugfs_remove(queues);
+err_state:
+        debugfs_remove(root);
+err_root:
+        dev_err(udc->dev, "debugfs is not available\n");
+}
+
+static void pxa_cleanup_debugfs(struct pxa_udc *udc)
+{
+        debugfs_remove(udc->debugfs_eps);
+        debugfs_remove(udc->debugfs_queues);
+        debugfs_remove(udc->debugfs_state);
+        debugfs_remove(udc->debugfs_root);
+        udc->debugfs_eps = NULL;
+        udc->debugfs_queues = NULL;
+        udc->debugfs_state = NULL;
+        udc->debugfs_root = NULL;
+}
+
+#else
+static inline void pxa_init_debugfs(struct pxa_udc *udc)
+{
+}
+
+static inline void pxa_cleanup_debugfs(struct pxa_udc *udc)
+{
+}
+#endif
+
+/**
+ * is_match_usb_pxa - check if usb_ep and pxa_ep match
+ * @udc_usb_ep: usb endpoint
+ * @ep: pxa endpoint
+ * @config: configuration required in pxa_ep
+ * @interface: interface required in pxa_ep
+ * @altsetting: altsetting required in pxa_ep
+ *
+ * Returns 1 if all criteria match between pxa and usb endpoint, 0 otherwise
+ */
+static int is_match_usb_pxa(struct udc_usb_ep *udc_usb_ep, struct pxa_ep *ep,
+                int config, int interface, int altsetting)
+{
+        if (usb_endpoint_num(&udc_usb_ep->desc) != ep->addr)
+                return 0;
+        if (usb_endpoint_dir_in(&udc_usb_ep->desc) != ep->dir_in)
+                return 0;
+        if (usb_endpoint_type(&udc_usb_ep->desc) != ep->type)
+                return 0;
+        if ((ep->config != config) || (ep->interface != interface)
+                        || (ep->alternate != altsetting))
+                return 0;
+        return 1;
+}
+
+/**
+ * find_pxa_ep - find pxa_ep structure matching udc_usb_ep
+ * @udc: pxa udc
+ * @udc_usb_ep: udc_usb_ep structure
+ *
+ * Match udc_usb_ep and all pxa_ep available, to see if one matches.
+ * This is necessary because of the strong pxa hardware restriction requiring
+ * that once pxa endpoints are initialized, their configuration is freezed, and
+ * no change can be made to their address, direction, or in which configuration,
+ * interface or altsetting they are active ... which differs from more usual
+ * models which have endpoints be roughly just addressable fifos, and leave
+ * configuration events up to gadget drivers (like all control messages).
+ *
+ * Note that there is still a blurred point here :
+ *   - we rely on UDCCR register "active interface" and "active altsetting".
+ *     This is a nonsense in regard of USB spec, where multiple interfaces are
+ *     active at the same time.
+ *   - if we knew for sure that the pxa can handle multiple interface at the
+ *     same time, assuming Intel's Developer Guide is wrong, this function
+ *     should be reviewed, and a cache of couples (iface, altsetting) should
+ *     be kept in the pxa_udc structure. In this case this function would match
+ *     against the cache of couples instead of the "last altsetting" set up.
+ *
+ * Returns the matched pxa_ep structure or NULL if none found
+ */
+static struct pxa_ep *find_pxa_ep(struct pxa_udc *udc,
+                struct udc_usb_ep *udc_usb_ep)
+{
+        int i;
+        struct pxa_ep *ep;
+        int cfg = udc->config;
+        int iface = udc->last_interface;
+        int alt = udc->last_alternate;
+
+        if (udc_usb_ep == &udc->udc_usb_ep[0])
+                return &udc->pxa_ep[0];
+
+        for (i = 1; i < NR_PXA_ENDPOINTS; i++) {
+                ep = &udc->pxa_ep[i];
+                if (is_match_usb_pxa(udc_usb_ep, ep, cfg, iface, alt))
+                        return ep;
+        }
+        return NULL;
+}
+
+/**
+ * update_pxa_ep_matches - update pxa_ep cached values in all udc_usb_ep
+ * @udc: pxa udc
+ *
+ * Context: in_interrupt()
+ *
+ * Updates all pxa_ep fields in udc_usb_ep structures, if this field was
+ * previously set up (and is not NULL). The update is necessary is a
+ * configuration change or altsetting change was issued by the USB host.
+ */
+static void update_pxa_ep_matches(struct pxa_udc *udc)
+{
+        int i;
+        struct udc_usb_ep *udc_usb_ep;
+
+        for (i = 1; i < NR_USB_ENDPOINTS; i++) {
+                udc_usb_ep = &udc->udc_usb_ep[i];
+                if (udc_usb_ep->pxa_ep)
+                        udc_usb_ep->pxa_ep = find_pxa_ep(udc, udc_usb_ep);
+        }
+}
+
+/**
+ * pio_irq_enable - Enables irq generation for one endpoint
+ * @ep: udc endpoint
+ */
+static void pio_irq_enable(struct pxa_ep *ep)
+{
+        struct pxa_udc *udc = ep->dev;
+        int index = EPIDX(ep);
+        u32 udcicr0 = udc_readl(udc, UDCICR0);
+        u32 udcicr1 = udc_readl(udc, UDCICR1);
+
+        if (index < 16)
+                udc_writel(udc, UDCICR0, udcicr0 | (3 << (index * 2)));
+        else
+                udc_writel(udc, UDCICR1, udcicr1 | (3 << ((index - 16) * 2)));
+}
+
+/**
+ * pio_irq_disable - Disables irq generation for one endpoint
+ * @ep: udc endpoint
+ * @index: endpoint number
+ */
+static void pio_irq_disable(struct pxa_ep *ep)
+{
+        struct pxa_udc *udc = ep->dev;
+        int index = EPIDX(ep);
+        u32 udcicr0 = udc_readl(udc, UDCICR0);
+        u32 udcicr1 = udc_readl(udc, UDCICR1);
+
+        if (index < 16)
+                udc_writel(udc, UDCICR0, udcicr0 & ~(3 << (index * 2)));
+        else
+                udc_writel(udc, UDCICR1, udcicr1 & ~(3 << ((index - 16) * 2)));
+}
+
+/**
+ * udc_set_mask_UDCCR - set bits in UDCCR
+ * @udc: udc device
+ * @mask: bits to set in UDCCR
+ *
+ * Sets bits in UDCCR, leaving DME and FST bits as they were.
+ */
+static inline void udc_set_mask_UDCCR(struct pxa_udc *udc, int mask)
+{
+        u32 udccr = udc_readl(udc, UDCCR);
+        udc_writel(udc, UDCCR,
+                        (udccr & UDCCR_MASK_BITS) | (mask & UDCCR_MASK_BITS));
+}
+
+/**
+ * udc_clear_mask_UDCCR - clears bits in UDCCR
+ * @udc: udc device
+ * @mask: bit to clear in UDCCR
+ *
+ * Clears bits in UDCCR, leaving DME and FST bits as they were.
+ */
+static inline void udc_clear_mask_UDCCR(struct pxa_udc *udc, int mask)
+{
+        u32 udccr = udc_readl(udc, UDCCR);
+        udc_writel(udc, UDCCR,
+                        (udccr & UDCCR_MASK_BITS) & ~(mask & UDCCR_MASK_BITS));
+}
+
+/**
+ * ep_count_bytes_remain - get how many bytes in udc endpoint
+ * @ep: udc endpoint
+ *
+ * Returns number of bytes in OUT fifos. Broken for IN fifos (-EOPNOTSUPP)
+ */
+static int ep_count_bytes_remain(struct pxa_ep *ep)
+{
+        if (ep->dir_in)
+                return -EOPNOTSUPP;
+        return udc_ep_readl(ep, UDCBCR) & 0x3ff;
+}
+
+/**
+ * ep_is_empty - checks if ep has byte ready for reading
+ * @ep: udc endpoint
+ *
+ * If endpoint is the control endpoint, checks if there are bytes in the
+ * control endpoint fifo. If endpoint is a data endpoint, checks if bytes
+ * are ready for reading on OUT endpoint.
+ *
+ * Returns 0 if ep not empty, 1 if ep empty, -EOPNOTSUPP if IN endpoint
+ */
+static int ep_is_empty(struct pxa_ep *ep)
+{
+        int ret;
+
+        if (!is_ep0(ep) && ep->dir_in)
+                return -EOPNOTSUPP;
+        if (is_ep0(ep))
+                ret = !(udc_ep_readl(ep, UDCCSR) & UDCCSR0_RNE);
+        else
+                ret = !(udc_ep_readl(ep, UDCCSR) & UDCCSR_BNE);
+        return ret;
+}
+
+/**
+ * ep_is_full - checks if ep has place to write bytes
+ * @ep: udc endpoint
+ *
+ * If endpoint is not the control endpoint and is an IN endpoint, checks if
+ * there is place to write bytes into the endpoint.
+ *
+ * Returns 0 if ep not full, 1 if ep full, -EOPNOTSUPP if OUT endpoint
+ */
+static int ep_is_full(struct pxa_ep *ep)
+{
+        if (is_ep0(ep))
+                return (udc_ep_readl(ep, UDCCSR) & UDCCSR0_IPR);
+        if (!ep->dir_in)
+                return -EOPNOTSUPP;
+        return (!(udc_ep_readl(ep, UDCCSR) & UDCCSR_BNF));
+}
+
+/**
+ * epout_has_pkt - checks if OUT endpoint fifo has a packet available
+ * @ep: pxa endpoint
+ *
+ * Returns 1 if a complete packet is available, 0 if not, -EOPNOTSUPP for IN ep.
+ */
+static int epout_has_pkt(struct pxa_ep *ep)
+{
+        if (!is_ep0(ep) && ep->dir_in)
+                return -EOPNOTSUPP;
+        if (is_ep0(ep))
+                return (udc_ep_readl(ep, UDCCSR) & UDCCSR0_OPC);
+        return (udc_ep_readl(ep, UDCCSR) & UDCCSR_PC);
+}
+
+/**
+ * set_ep0state - Set ep0 automata state
+ * @dev: udc device
+ * @state: state
+ */
+static void set_ep0state(struct pxa_udc *udc, int state)
+{
+        struct pxa_ep *ep = &udc->pxa_ep[0];
+        char *old_stname = EP0_STNAME(udc);
+
+        udc->ep0state = state;
+        ep_dbg(ep, "state=%s->%s, udccsr0=0x%03x, udcbcr=%d\n", old_stname,
+                EP0_STNAME(udc), udc_ep_readl(ep, UDCCSR),
+                udc_ep_readl(ep, UDCBCR));
+}
+
+/**
+ * ep0_idle - Put control endpoint into idle state
+ * @dev: udc device
+ */
+static void ep0_idle(struct pxa_udc *dev)
+{
+        set_ep0state(dev, WAIT_FOR_SETUP);
+}
+
+/**
+ * inc_ep_stats_reqs - Update ep stats counts
+ * @ep: physical endpoint
+ * @req: usb request
+ * @is_in: ep direction (USB_DIR_IN or 0)
+ *
+ */
+static void inc_ep_stats_reqs(struct pxa_ep *ep, int is_in)
+{
+        if (is_in)
+                ep->stats.in_ops++;
+        else
+                ep->stats.out_ops++;
+}
+
+/**
+ * inc_ep_stats_bytes - Update ep stats counts
+ * @ep: physical endpoint
+ * @count: bytes transfered on endpoint
+ * @req: usb request
+ * @is_in: ep direction (USB_DIR_IN or 0)
+ */
+static void inc_ep_stats_bytes(struct pxa_ep *ep, int count, int is_in)
+{
+        if (is_in)
+                ep->stats.in_bytes += count;
+        else
+                ep->stats.out_bytes += count;
+}
+
+/**
+ * pxa_ep_setup - Sets up an usb physical endpoint
+ * @ep: pxa27x physical endpoint
+ *
+ * Find the physical pxa27x ep, and setup its UDCCR
+ */
+static __init void pxa_ep_setup(struct pxa_ep *ep)
+{
+        u32 new_udccr;
+
+        new_udccr = ((ep->config << UDCCONR_CN_S) & UDCCONR_CN)
+                | ((ep->interface << UDCCONR_IN_S) & UDCCONR_IN)
+                | ((ep->alternate << UDCCONR_AISN_S) & UDCCONR_AISN)
+                | ((EPADDR(ep) << UDCCONR_EN_S) & UDCCONR_EN)
+                | ((EPXFERTYPE(ep) << UDCCONR_ET_S) & UDCCONR_ET)
+                | ((ep->dir_in) ? UDCCONR_ED : 0)
+                | ((ep->fifo_size << UDCCONR_MPS_S) & UDCCONR_MPS)
+                | UDCCONR_EE;
+
+        udc_ep_writel(ep, UDCCR, new_udccr);
+}
+
+/**
+ * pxa_eps_setup - Sets up all usb physical endpoints
+ * @dev: udc device
+ *
+ * Setup all pxa physical endpoints, except ep0
+ */
+static __init void pxa_eps_setup(struct pxa_udc *dev)
+{
+        unsigned int i;
+
+        dev_dbg(dev->dev, "%s: dev=%p\n", __func__, dev);
+
+        for (i = 1; i < NR_PXA_ENDPOINTS; i++)
+                pxa_ep_setup(&dev->pxa_ep[i]);
+}
+
+/**
+ * pxa_ep_alloc_request - Allocate usb request
+ * @_ep: usb endpoint
+ * @gfp_flags:
+ *
+ * For the pxa27x, these can just wrap kmalloc/kfree.  gadget drivers
+ * must still pass correctly initialized endpoints, since other controller
+ * drivers may care about how it's currently set up (dma issues etc).
+  */
+static struct usb_request *
+pxa_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
+{
+        struct pxa27x_request *req;
+
+        req = kzalloc(sizeof *req, gfp_flags);
+        if (!req || !_ep)
+                return NULL;
+
+        INIT_LIST_HEAD(&req->queue);
+        req->in_use = 0;
+        req->udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
+
+        return &req->req;
+}
+
+/**
+ * pxa_ep_free_request - Free usb request
+ * @_ep: usb endpoint
+ * @_req: usb request
+ *
+ * Wrapper around kfree to free _req
+ */
+static void pxa_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct pxa27x_request *req;
+
+        req = container_of(_req, struct pxa27x_request, req);
+        WARN_ON(!list_empty(&req->queue));
+        kfree(req);
+}
+
+/**
+ * ep_add_request - add a request to the endpoint's queue
+ * @ep: usb endpoint
+ * @req: usb request
+ *
+ * Context: ep->lock held
+ *
+ * Queues the request in the endpoint's queue, and enables the interrupts
+ * on the endpoint.
+ */
+static void ep_add_request(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        if (unlikely(!req))
+                return;
+        ep_vdbg(ep, "req:%p, lg=%d, udccsr=0x%03x\n", req,
+                req->req.length, udc_ep_readl(ep, UDCCSR));
+
+        req->in_use = 1;
+        list_add_tail(&req->queue, &ep->queue);
+        pio_irq_enable(ep);
+}
+
+/**
+ * ep_del_request - removes a request from the endpoint's queue
+ * @ep: usb endpoint
+ * @req: usb request
+ *
+ * Context: ep->lock held
+ *
+ * Unqueue the request from the endpoint's queue. If there are no more requests
+ * on the endpoint, and if it's not the control endpoint, interrupts are
+ * disabled on the endpoint.
+ */
+static void ep_del_request(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        if (unlikely(!req))
+                return;
+        ep_vdbg(ep, "req:%p, lg=%d, udccsr=0x%03x\n", req,
+                req->req.length, udc_ep_readl(ep, UDCCSR));
+
+        list_del_init(&req->queue);
+        req->in_use = 0;
+        if (!is_ep0(ep) && list_empty(&ep->queue))
+                pio_irq_disable(ep);
+}
+
+/**
+ * req_done - Complete an usb request
+ * @ep: pxa physical endpoint
+ * @req: pxa request
+ * @status: usb request status sent to gadget API
+ *
+ * Context: ep->lock held
+ *
+ * Retire a pxa27x usb request. Endpoint must be locked.
+ */
+static void req_done(struct pxa_ep *ep, struct pxa27x_request *req, int status)
+{
+        ep_del_request(ep, req);
+        if (likely(req->req.status == -EINPROGRESS))
+                req->req.status = status;
+        else
+                status = req->req.status;
+
+        if (status && status != -ESHUTDOWN)
+                ep_dbg(ep, "complete req %p stat %d len %u/%u\n",
+                        &req->req, status,
+                        req->req.actual, req->req.length);
+
+        req->req.complete(&req->udc_usb_ep->usb_ep, &req->req);
+}
+
+/**
+ * ep_end_out_req - Ends control endpoint in request
+ * @ep: physical endpoint
+ * @req: pxa request
+ *
+ * Context: ep->lock held
+ *
+ * Ends endpoint in request (completes usb request).
+ */
+static void ep_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        inc_ep_stats_reqs(ep, !USB_DIR_IN);
+        req_done(ep, req, 0);
+}
+
+/**
+ * ep0_end_out_req - Ends control endpoint in request (ends data stage)
+ * @ep: physical endpoint
+ * @req: pxa request
+ *
+ * Context: ep->lock held
+ *
+ * Ends control endpoint in request (completes usb request), and puts
+ * control endpoint into idle state
+ */
+static void ep0_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        set_ep0state(ep->dev, OUT_STATUS_STAGE);
+        ep_end_out_req(ep, req);
+        ep0_idle(ep->dev);
+}
+
+/**
+ * ep_end_in_req - Ends endpoint out request
+ * @ep: physical endpoint
+ * @req: pxa request
+ *
+ * Context: ep->lock held
+ *
+ * Ends endpoint out request (completes usb request).
+ */
+static void ep_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        inc_ep_stats_reqs(ep, USB_DIR_IN);
+        req_done(ep, req, 0);
+}
+
+/**
+ * ep0_end_in_req - Ends control endpoint out request (ends data stage)
+ * @ep: physical endpoint
+ * @req: pxa request
+ *
+ * Context: ep->lock held
+ *
+ * Ends control endpoint out request (completes usb request), and puts
+ * control endpoint into status state
+ */
+static void ep0_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        struct pxa_udc *udc = ep->dev;
+
+        set_ep0state(udc, IN_STATUS_STAGE);
+        ep_end_in_req(ep, req);
+}
+
+/**
+ * nuke - Dequeue all requests
+ * @ep: pxa endpoint
+ * @status: usb request status
+ *
+ * Context: ep->lock held
+ *
+ * Dequeues all requests on an endpoint. As a side effect, interrupts will be
+ * disabled on that endpoint (because no more requests).
+ */
+static void nuke(struct pxa_ep *ep, int status)
+{
+        struct pxa27x_request *req;
+
+        while (!list_empty(&ep->queue)) {
+                req = list_entry(ep->queue.next, struct pxa27x_request, queue);
+                req_done(ep, req, status);
+        }
+}
+
+/**
+ * read_packet - transfer 1 packet from an OUT endpoint into request
+ * @ep: pxa physical endpoint
+ * @req: usb request
+ *
+ * Takes bytes from OUT endpoint and transfers them info the usb request.
+ * If there is less space in request than bytes received in OUT endpoint,
+ * bytes are left in the OUT endpoint.
+ *
+ * Returns how many bytes were actually transfered
+ */
+static int read_packet(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        u32 *buf;
+        int bytes_ep, bufferspace, count, i;
+
+        bytes_ep = ep_count_bytes_remain(ep);
+        bufferspace = req->req.length - req->req.actual;
+
+        buf = (u32 *)(req->req.buf + req->req.actual);
+        prefetchw(buf);
+
+        if (likely(!ep_is_empty(ep)))
+                count = min(bytes_ep, bufferspace);
+        else /* zlp */
+                count = 0;
+
+        for (i = count; i > 0; i -= 4)
+                *buf++ = udc_ep_readl(ep, UDCDR);
+        req->req.actual += count;
+
+        udc_ep_writel(ep, UDCCSR, UDCCSR_PC);
+
+        return count;
+}
+
+/**
+ * write_packet - transfer 1 packet from request into an IN endpoint
+ * @ep: pxa physical endpoint
+ * @req: usb request
+ * @max: max bytes that fit into endpoint
+ *
+ * Takes bytes from usb request, and transfers them into the physical
+ * endpoint. If there are no bytes to transfer, doesn't write anything
+ * to physical endpoint.
+ *
+ * Returns how many bytes were actually transfered.
+ */
+static int write_packet(struct pxa_ep *ep, struct pxa27x_request *req,
+                        unsigned int max)
+{
+        int length, count, remain, i;
+        u32 *buf;
+        u8 *buf_8;
+
+        buf = (u32 *)(req->req.buf + req->req.actual);
+        prefetch(buf);
+
+        length = min(req->req.length - req->req.actual, max);
+        req->req.actual += length;
+
+        remain = length & 0x3;
+        count = length & ~(0x3);
+        for (i = count; i > 0 ; i -= 4)
+                udc_ep_writel(ep, UDCDR, *buf++);
+
+        buf_8 = (u8 *)buf;
+        for (i = remain; i > 0; i--)
+                udc_ep_writeb(ep, UDCDR, *buf_8++);
+
+        ep_vdbg(ep, "length=%d+%d, udccsr=0x%03x\n", count, remain,
+                udc_ep_readl(ep, UDCCSR));
+
+        return length;
+}
+
+/**
+ * read_fifo - Transfer packets from OUT endpoint into usb request
+ * @ep: pxa physical endpoint
+ * @req: usb request
+ *
+ * Context: callable when in_interrupt()
+ *
+ * Unload as many packets as possible from the fifo we use for usb OUT
+ * transfers and put them into the request. Caller should have made sure
+ * there's at least one packet ready.
+ * Doesn't complete the request, that's the caller's job
+ *
+ * Returns 1 if the request completed, 0 otherwise
+ */
+static int read_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        int count, is_short, completed = 0;
+
+        while (epout_has_pkt(ep)) {
+                count = read_packet(ep, req);
+                inc_ep_stats_bytes(ep, count, !USB_DIR_IN);
+
+                is_short = (count < ep->fifo_size);
+                ep_dbg(ep, "read udccsr:%03x, count:%d bytes%s req %p %d/%d\n",
+                        udc_ep_readl(ep, UDCCSR), count, is_short ? "/S" : "",
+                        &req->req, req->req.actual, req->req.length);
+
+                /* completion */
+                if (is_short || req->req.actual == req->req.length) {
+                        completed = 1;
+                        break;
+                }
+                /* finished that packet.  the next one may be waiting... */
+        }
+        return completed;
+}
+
+/**
+ * write_fifo - transfer packets from usb request into an IN endpoint
+ * @ep: pxa physical endpoint
+ * @req: pxa usb request
+ *
+ * Write to an IN endpoint fifo, as many packets as possible.
+ * irqs will use this to write the rest later.
+ * caller guarantees at least one packet buffer is ready (or a zlp).
+ * Doesn't complete the request, that's the caller's job
+ *
+ * Returns 1 if request fully transfered, 0 if partial transfer
+ */
+static int write_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        unsigned max;
+        int count, is_short, is_last = 0, completed = 0, totcount = 0;
+        u32 udccsr;
+
+        max = ep->fifo_size;
+        do {
+                is_short = 0;
+
+                udccsr = udc_ep_readl(ep, UDCCSR);
+                if (udccsr & UDCCSR_PC) {
+                        ep_vdbg(ep, "Clearing Transmit Complete, udccsr=%x\n",
+                                udccsr);
+                        udc_ep_writel(ep, UDCCSR, UDCCSR_PC);
+                }
+                if (udccsr & UDCCSR_TRN) {
+                        ep_vdbg(ep, "Clearing Underrun on, udccsr=%x\n",
+                                udccsr);
+                        udc_ep_writel(ep, UDCCSR, UDCCSR_TRN);
+                }
+
+                count = write_packet(ep, req, max);
+                inc_ep_stats_bytes(ep, count, USB_DIR_IN);
+                totcount += count;
+
+                /* last packet is usually short (or a zlp) */
+                if (unlikely(count < max)) {
+                        is_last = 1;
+                        is_short = 1;
+                } else {
+                        if (likely(req->req.length > req->req.actual)
+                                        || req->req.zero)
+                                is_last = 0;
+                        else
+                                is_last = 1;
+                        /* interrupt/iso maxpacket may not fill the fifo */
+                        is_short = unlikely(max < ep->fifo_size);
+                }
+
+                if (is_short)
+                        udc_ep_writel(ep, UDCCSR, UDCCSR_SP);
+
+                /* requests complete when all IN data is in the FIFO */
+                if (is_last) {
+                        completed = 1;
+                        break;
+                }
+        } while (!ep_is_full(ep));
+
+        ep_dbg(ep, "wrote count:%d bytes%s%s, left:%d req=%p\n",
+                        totcount, is_last ? "/L" : "", is_short ? "/S" : "",
+                        req->req.length - req->req.actual, &req->req);
+
+        return completed;
+}
+
+/**
+ * read_ep0_fifo - Transfer packets from control endpoint into usb request
+ * @ep: control endpoint
+ * @req: pxa usb request
+ *
+ * Special ep0 version of the above read_fifo. Reads as many bytes from control
+ * endpoint as can be read, and stores them into usb request (limited by request
+ * maximum length).
+ *
+ * Returns 0 if usb request only partially filled, 1 if fully filled
+ */
+static int read_ep0_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        int count, is_short, completed = 0;
+
+        while (epout_has_pkt(ep)) {
+                count = read_packet(ep, req);
+                udc_ep_writel(ep, UDCCSR, UDCCSR0_OPC);
+                inc_ep_stats_bytes(ep, count, !USB_DIR_IN);
+
+                is_short = (count < ep->fifo_size);
+                ep_dbg(ep, "read udccsr:%03x, count:%d bytes%s req %p %d/%d\n",
+                        udc_ep_readl(ep, UDCCSR), count, is_short ? "/S" : "",
+                        &req->req, req->req.actual, req->req.length);
+
+                if (is_short || req->req.actual >= req->req.length) {
+                        completed = 1;
+                        break;
+                }
+        }
+
+        return completed;
+}
+
+/**
+ * write_ep0_fifo - Send a request to control endpoint (ep0 in)
+ * @ep: control endpoint
+ * @req: request
+ *
+ * Context: callable when in_interrupt()
+ *
+ * Sends a request (or a part of the request) to the control endpoint (ep0 in).
+ * If the request doesn't fit, the remaining part will be sent from irq.
+ * The request is considered fully written only if either :
+ *   - last write transfered all remaining bytes, but fifo was not fully filled
+ *   - last write was a 0 length write
+ *
+ * Returns 1 if request fully written, 0 if request only partially sent
+ */
+static int write_ep0_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
+{
+        unsigned        count;
+        int             is_last, is_short;
+
+        count = write_packet(ep, req, EP0_FIFO_SIZE);
+        inc_ep_stats_bytes(ep, count, USB_DIR_IN);
+
+        is_short = (count < EP0_FIFO_SIZE);
+        is_last = ((count == 0) || (count < EP0_FIFO_SIZE));
+
+        /* Sends either a short packet or a 0 length packet */
+        if (unlikely(is_short))
+                udc_ep_writel(ep, UDCCSR, UDCCSR0_IPR);
+
+        ep_dbg(ep, "in %d bytes%s%s, %d left, req=%p, udccsr0=0x%03x\n",
+                count, is_short ? "/S" : "", is_last ? "/L" : "",
+                req->req.length - req->req.actual,
+                &req->req, udc_ep_readl(ep, UDCCSR));
+
+        return is_last;
+}
+
+/**
+ * pxa_ep_queue - Queue a request into an IN endpoint
+ * @_ep: usb endpoint
+ * @_req: usb request
+ * @gfp_flags: flags
+ *
+ * Context: normally called when !in_interrupt, but callable when in_interrupt()
+ * in the special case of ep0 setup :
+ *   (irq->handle_ep0_ctrl_req->gadget_setup->pxa_ep_queue)
+ *
+ * Returns 0 if succedeed, error otherwise
+ */
+static int pxa_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
+                        gfp_t gfp_flags)
+{
+        struct udc_usb_ep       *udc_usb_ep;
+        struct pxa_ep           *ep;
+        struct pxa27x_request   *req;
+        struct pxa_udc          *dev;
+        unsigned long           flags;
+        int                     rc = 0;
+        int                     is_first_req;
+        unsigned                length;
+
+        req = container_of(_req, struct pxa27x_request, req);
+        udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
+
+        if (unlikely(!_req || !_req->complete || !_req->buf))
+                return -EINVAL;
+
+        if (unlikely(!_ep))
+                return -EINVAL;
+
+        dev = udc_usb_ep->dev;
+        ep = udc_usb_ep->pxa_ep;
+        if (unlikely(!ep))
+                return -EINVAL;
+
+        dev = ep->dev;
+        if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
+                ep_dbg(ep, "bogus device state\n");
+                return -ESHUTDOWN;
+        }
+
+        /* iso is always one packet per request, that's the only way
+         * we can report per-packet status.  that also helps with dma.
+         */
+        if (unlikely(EPXFERTYPE_is_ISO(ep)
+                        && req->req.length > ep->fifo_size))
+                return -EMSGSIZE;
+
+        spin_lock_irqsave(&ep->lock, flags);
+
+        is_first_req = list_empty(&ep->queue);
+        ep_dbg(ep, "queue req %p(first=%s), len %d buf %p\n",
+                        _req, is_first_req ? "yes" : "no",
+                        _req->length, _req->buf);
+
+        if (!ep->enabled) {
+                _req->status = -ESHUTDOWN;
+                rc = -ESHUTDOWN;
+                goto out;
+        }
+
+        if (req->in_use) {
+                ep_err(ep, "refusing to queue req %p (already queued)\n", req);
+                goto out;
+        }
+
+        length = _req->length;
+        _req->status = -EINPROGRESS;
+        _req->actual = 0;
+
+        ep_add_request(ep, req);
+
+        if (is_ep0(ep)) {
+                switch (dev->ep0state) {
+                case WAIT_ACK_SET_CONF_INTERF:
+                        if (length == 0) {
+                                ep_end_in_req(ep, req);
+                        } else {
+                                ep_err(ep, "got a request of %d bytes while"
+                                        "in state WATI_ACK_SET_CONF_INTERF\n",
+                                        length);
+                                ep_del_request(ep, req);
+                                rc = -EL2HLT;
+                        }
+                        ep0_idle(ep->dev);
+                        break;
+                case IN_DATA_STAGE:
+                        if (!ep_is_full(ep))
+                                if (write_ep0_fifo(ep, req))
+                                        ep0_end_in_req(ep, req);
+                        break;
+                case OUT_DATA_STAGE:
+                        if ((length == 0) || !epout_has_pkt(ep))
+                                if (read_ep0_fifo(ep, req))
+                                        ep0_end_out_req(ep, req);
+                        break;
+                default:
+                        ep_err(ep, "odd state %s to send me a request\n",
+                                EP0_STNAME(ep->dev));
+                        ep_del_request(ep, req);
+                        rc = -EL2HLT;
+                        break;
+                }
+        } else {
+                handle_ep(ep);
+        }
+
+out:
+        spin_unlock_irqrestore(&ep->lock, flags);
+        return rc;
+}
+
+/**
+ * pxa_ep_dequeue - Dequeue one request
+ * @_ep: usb endpoint
+ * @_req: usb request
+ *
+ * Return 0 if no error, -EINVAL or -ECONNRESET otherwise
+ */
+static int pxa_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct pxa_ep           *ep;
+        struct udc_usb_ep       *udc_usb_ep;
+        struct pxa27x_request   *req;
+        unsigned long           flags;
+        int                     rc;
+
+        if (!_ep)
+                return -EINVAL;
+        udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
+        ep = udc_usb_ep->pxa_ep;
+        if (!ep || is_ep0(ep))
+                return -EINVAL;
+
+        spin_lock_irqsave(&ep->lock, flags);
+
+        /* make sure it's actually queued on this endpoint */
+        list_for_each_entry(req, &ep->queue, queue) {
+                if (&req->req == _req)
+                        break;
+        }
+
+        rc = -EINVAL;
+        if (&req->req != _req)
+                goto out;
+
+        rc = 0;
+        req_done(ep, req, -ECONNRESET);
+out:
+        spin_unlock_irqrestore(&ep->lock, flags);
+        return rc;
+}
+
+/**
+ * pxa_ep_set_halt - Halts operations on one endpoint
+ * @_ep: usb endpoint
+ * @value:
+ *
+ * Returns 0 if no error, -EINVAL, -EROFS, -EAGAIN otherwise
+ */
+static int pxa_ep_set_halt(struct usb_ep *_ep, int value)
+{
+        struct pxa_ep           *ep;
+        struct udc_usb_ep       *udc_usb_ep;
+        unsigned long flags;
+        int rc;
+
+
+        if (!_ep)
+                return -EINVAL;
+        udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
+        ep = udc_usb_ep->pxa_ep;
+        if (!ep || is_ep0(ep))
+                return -EINVAL;
+
+        if (value == 0) {
+                /*
+                 * This path (reset toggle+halt) is needed to implement
+                 * SET_INTERFACE on normal hardware.  but it can't be
+                 * done from software on the PXA UDC, and the hardware
+                 * forgets to do it as part of SET_INTERFACE automagic.
+                 */
+                ep_dbg(ep, "only host can clear halt\n");
+                return -EROFS;
+        }
+
+        spin_lock_irqsave(&ep->lock, flags);
+
+        rc = -EAGAIN;
+        if (ep->dir_in  && (ep_is_full(ep) || !list_empty(&ep->queue)))
+                goto out;
+
+        /* FST, FEF bits are the same for control and non control endpoints */
+        rc = 0;
+        udc_ep_writel(ep, UDCCSR, UDCCSR_FST | UDCCSR_FEF);
+        if (is_ep0(ep))
+                set_ep0state(ep->dev, STALL);
+
+out:
+        spin_unlock_irqrestore(&ep->lock, flags);
+        return rc;
+}
+
+/**
+ * pxa_ep_fifo_status - Get how many bytes in physical endpoint
+ * @_ep: usb endpoint
+ *
+ * Returns number of bytes in OUT fifos. Broken for IN fifos.
+ */
+static int pxa_ep_fifo_status(struct usb_ep *_ep)
+{
+        struct pxa_ep           *ep;
+        struct udc_usb_ep       *udc_usb_ep;
+
+        if (!_ep)
+                return -ENODEV;
+        udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
+        ep = udc_usb_ep->pxa_ep;
+        if (!ep || is_ep0(ep))
+                return -ENODEV;
+
+        if (ep->dir_in)
+                return -EOPNOTSUPP;
+        if (ep->dev->gadget.speed == USB_SPEED_UNKNOWN || ep_is_empty(ep))
+                return 0;
+        else
+                return ep_count_bytes_remain(ep) + 1;
+}
+
+/**
+ * pxa_ep_fifo_flush - Flushes one endpoint
+ * @_ep: usb endpoint
+ *
+ * Discards all data in one endpoint(IN or OUT), except control endpoint.
+ */
+static void pxa_ep_fifo_flush(struct usb_ep *_ep)
+{
+        struct pxa_ep           *ep;
+        struct udc_usb_ep       *udc_usb_ep;
+        unsigned long           flags;
+
+        if (!_ep)
+                return;
+        udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
+        ep = udc_usb_ep->pxa_ep;
+        if (!ep || is_ep0(ep))
+                return;
+
+        spin_lock_irqsave(&ep->lock, flags);
+
+        if (unlikely(!list_empty(&ep->queue)))
+                ep_dbg(ep, "called while queue list not empty\n");
+        ep_dbg(ep, "called\n");
+
+        /* for OUT, just read and discard the FIFO contents. */
+        if (!ep->dir_in) {
+                while (!ep_is_empty(ep))
+                        udc_ep_readl(ep, UDCDR);
+        } else {
+                /* most IN status is the same, but ISO can't stall */
+                udc_ep_writel(ep, UDCCSR,
+                                UDCCSR_PC | UDCCSR_FEF | UDCCSR_TRN
+                                | (EPXFERTYPE_is_ISO(ep) ? 0 : UDCCSR_SST));
+        }
+
+        spin_unlock_irqrestore(&ep->lock, flags);
+
+        return;
+}
+
+/**
+ * pxa_ep_enable - Enables usb endpoint
+ * @_ep: usb endpoint
+ * @desc: usb endpoint descriptor
+ *
+ * Nothing much to do here, as ep configuration is done once and for all
+ * before udc is enabled. After udc enable, no physical endpoint configuration
+ * can be changed.
+ * Function makes sanity checks and flushes the endpoint.
+ */
+static int pxa_ep_enable(struct usb_ep *_ep,
+        const struct usb_endpoint_descriptor *desc)
+{
+        struct pxa_ep           *ep;
+        struct udc_usb_ep       *udc_usb_ep;
+        struct pxa_udc          *udc;
+
+        if (!_ep || !desc)
+                return -EINVAL;
+
+        udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
+        if (udc_usb_ep->pxa_ep) {
+                ep = udc_usb_ep->pxa_ep;
+                ep_warn(ep, "usb_ep %s already enabled, doing nothing\n",
+                        _ep->name);
+        } else {
+                ep = find_pxa_ep(udc_usb_ep->dev, udc_usb_ep);
+        }
+
+        if (!ep || is_ep0(ep)) {
+                dev_err(udc_usb_ep->dev->dev,
+                        "unable to match pxa_ep for ep %s\n",
+                        _ep->name);
+                return -EINVAL;
+        }
+
+        if ((desc->bDescriptorType != USB_DT_ENDPOINT)
+                        || (ep->type != usb_endpoint_type(desc))) {
+                ep_err(ep, "type mismatch\n");
+                return -EINVAL;
+        }
+
+        if (ep->fifo_size < le16_to_cpu(desc->wMaxPacketSize)) {
+                ep_err(ep, "bad maxpacket\n");
+                return -ERANGE;
+        }
+
+        udc_usb_ep->pxa_ep = ep;
+        udc = ep->dev;
+
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
+                ep_err(ep, "bogus device state\n");
+                return -ESHUTDOWN;
+        }
+
+        ep->enabled = 1;
+
+        /* flush fifo (mostly for OUT buffers) */
+        pxa_ep_fifo_flush(_ep);
+
+        ep_dbg(ep, "enabled\n");
+        return 0;
+}
+
+/**
+ * pxa_ep_disable - Disable usb endpoint
+ * @_ep: usb endpoint
+ *
+ * Same as for pxa_ep_enable, no physical endpoint configuration can be
+ * changed.
+ * Function flushes the endpoint and related requests.
+ */
+static int pxa_ep_disable(struct usb_ep *_ep)
+{
+        struct pxa_ep           *ep;
+        struct udc_usb_ep       *udc_usb_ep;
+        unsigned long           flags;
+
+        if (!_ep)
+                return -EINVAL;
+
+        udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
+        ep = udc_usb_ep->pxa_ep;
+        if (!ep || is_ep0(ep) || !list_empty(&ep->queue))
+                return -EINVAL;
+
+        spin_lock_irqsave(&ep->lock, flags);
+        ep->enabled = 0;
+        nuke(ep, -ESHUTDOWN);
+        spin_unlock_irqrestore(&ep->lock, flags);
+
+        pxa_ep_fifo_flush(_ep);
+        udc_usb_ep->pxa_ep = NULL;
+
+        ep_dbg(ep, "disabled\n");
+        return 0;
+}
+
+static struct usb_ep_ops pxa_ep_ops = {
+        .enable         = pxa_ep_enable,
+        .disable        = pxa_ep_disable,
+
+        .alloc_request  = pxa_ep_alloc_request,
+        .free_request   = pxa_ep_free_request,
+
+        .queue          = pxa_ep_queue,
+        .dequeue        = pxa_ep_dequeue,
+
+        .set_halt       = pxa_ep_set_halt,
+        .fifo_status    = pxa_ep_fifo_status,
+        .fifo_flush     = pxa_ep_fifo_flush,
+};
+
+
+/**
+ * pxa_udc_get_frame - Returns usb frame number
+ * @_gadget: usb gadget
+ */
+static int pxa_udc_get_frame(struct usb_gadget *_gadget)
+{
+        struct pxa_udc *udc = to_gadget_udc(_gadget);
+
+        return (udc_readl(udc, UDCFNR) & 0x7ff);
+}
+
+/**
+ * pxa_udc_wakeup - Force udc device out of suspend
+ * @_gadget: usb gadget
+ *
+ * Returns 0 if succesfull, error code otherwise
+ */
+static int pxa_udc_wakeup(struct usb_gadget *_gadget)
+{
+        struct pxa_udc *udc = to_gadget_udc(_gadget);
+
+        /* host may not have enabled remote wakeup */
+        if ((udc_readl(udc, UDCCR) & UDCCR_DWRE) == 0)
+                return -EHOSTUNREACH;
+        udc_set_mask_UDCCR(udc, UDCCR_UDR);
+        return 0;
+}
+
+static const struct usb_gadget_ops pxa_udc_ops = {
+        .get_frame      = pxa_udc_get_frame,
+        .wakeup         = pxa_udc_wakeup,
+        /* current versions must always be self-powered */
+};
+
+/**
+ * udc_disable - disable udc device controller
+ * @udc: udc device
+ *
+ * Disables the udc device : disables clocks, udc interrupts, control endpoint
+ * interrupts.
+ */
+static void udc_disable(struct pxa_udc *udc)
+{
+        udc_writel(udc, UDCICR0, 0);
+        udc_writel(udc, UDCICR1, 0);
+
+        udc_clear_mask_UDCCR(udc, UDCCR_UDE);
+        clk_disable(udc->clk);
+
+        ep0_idle(udc);
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+        if (udc->mach->udc_command)
+                udc->mach->udc_command(PXA2XX_UDC_CMD_DISCONNECT);
+}
+
+/**
+ * udc_init_data - Initialize udc device data structures
+ * @dev: udc device
+ *
+ * Initializes gadget endpoint list, endpoints locks. No action is taken
+ * on the hardware.
+ */
+static __init void udc_init_data(struct pxa_udc *dev)
+{
+        int i;
+        struct pxa_ep *ep;
+
+        /* device/ep0 records init */
+        INIT_LIST_HEAD(&dev->gadget.ep_list);
+        INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
+        dev->udc_usb_ep[0].pxa_ep = &dev->pxa_ep[0];
+        ep0_idle(dev);
+
+        /* PXA endpoints init */
+        for (i = 0; i < NR_PXA_ENDPOINTS; i++) {
+                ep = &dev->pxa_ep[i];
+
+                ep->enabled = is_ep0(ep);
+                INIT_LIST_HEAD(&ep->queue);
+                spin_lock_init(&ep->lock);
+        }
+
+        /* USB endpoints init */
+        for (i = 0; i < NR_USB_ENDPOINTS; i++)
+                if (i != 0)
+                        list_add_tail(&dev->udc_usb_ep[i].usb_ep.ep_list,
+                                        &dev->gadget.ep_list);
+}
+
+/**
+ * udc_enable - Enables the udc device
+ * @dev: udc device
+ *
+ * Enables the udc device : enables clocks, udc interrupts, control endpoint
+ * interrupts, sets usb as UDC client and setups endpoints.
+ */
+static void udc_enable(struct pxa_udc *udc)
+{
+        udc_writel(udc, UDCICR0, 0);
+        udc_writel(udc, UDCICR1, 0);
+        udc_writel(udc, UP2OCR, UP2OCR_HXOE);
+        udc_clear_mask_UDCCR(udc, UDCCR_UDE);
+
+        clk_enable(udc->clk);
+
+        ep0_idle(udc);
+        udc->gadget.speed = USB_SPEED_FULL;
+        memset(&udc->stats, 0, sizeof(udc->stats));
+
+        udc_set_mask_UDCCR(udc, UDCCR_UDE);
+        udelay(2);
+        if (udc_readl(udc, UDCCR) & UDCCR_EMCE)
+                dev_err(udc->dev, "Configuration errors, udc disabled\n");
+
+        /*
+         * Caller must be able to sleep in order to cope with startup transients
+         */
+        msleep(100);
+
+        /* enable suspend/resume and reset irqs */
+        udc_writel(udc, UDCICR1,
+                        UDCICR1_IECC | UDCICR1_IERU
+                        | UDCICR1_IESU | UDCICR1_IERS);
+
+        /* enable ep0 irqs */
+        pio_irq_enable(&udc->pxa_ep[0]);
+
+        dev_info(udc->dev, "UDC connecting\n");
+        if (udc->mach->udc_command)
+                udc->mach->udc_command(PXA2XX_UDC_CMD_CONNECT);
+}
+
+/**
+ * usb_gadget_register_driver - Register gadget driver
+ * @driver: gadget driver
+ *
+ * When a driver is successfully registered, it will receive control requests
+ * including set_configuration(), which enables non-control requests.  Then
+ * usb traffic follows until a disconnect is reported.  Then a host may connect
+ * again, or the driver might get unbound.
+ *
+ * Returns 0 if no error, -EINVAL, -ENODEV, -EBUSY otherwise
+ */
+int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+{
+        struct pxa_udc *udc = the_controller;
+        int retval;
+
+        if (!driver || driver->speed != USB_SPEED_FULL || !driver->bind
+                        || !driver->disconnect || !driver->setup)
+                return -EINVAL;
+        if (!udc)
+                return -ENODEV;
+        if (udc->driver)
+                return -EBUSY;
+
+        /* first hook up the driver ... */
+        udc->driver = driver;
+        udc->gadget.dev.driver = &driver->driver;
+
+        retval = device_add(&udc->gadget.dev);
+        if (retval) {
+                dev_err(udc->dev, "device_add error %d\n", retval);
+                goto add_fail;
+        }
+        retval = driver->bind(&udc->gadget);
+        if (retval) {
+                dev_err(udc->dev, "bind to driver %s --> error %d\n",
+                        driver->driver.name, retval);
+                goto bind_fail;
+        }
+        dev_dbg(udc->dev, "registered gadget driver '%s'\n",
+                driver->driver.name);
+
+        udc_enable(udc);
+        return 0;
+
+bind_fail:
+        device_del(&udc->gadget.dev);
+add_fail:
+        udc->driver = NULL;
+        udc->gadget.dev.driver = NULL;
+        return retval;
+}
+EXPORT_SYMBOL(usb_gadget_register_driver);
+
+
+/**
+ * stop_activity - Stops udc endpoints
+ * @udc: udc device
+ * @driver: gadget driver
+ *
+ * Disables all udc endpoints (even control endpoint), report disconnect to
+ * the gadget user.
+ */
+static void stop_activity(struct pxa_udc *udc, struct usb_gadget_driver *driver)
+{
+        int i;
+
+        /* don't disconnect drivers more than once */
+        if (udc->gadget.speed == USB_SPEED_UNKNOWN)
+                driver = NULL;
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+
+        for (i = 0; i < NR_USB_ENDPOINTS; i++)
+                pxa_ep_disable(&udc->udc_usb_ep[i].usb_ep);
+
+        if (driver)
+                driver->disconnect(&udc->gadget);
+}
+
+/**
+ * usb_gadget_unregister_driver - Unregister the gadget driver
+ * @driver: gadget driver
+ *
+ * Returns 0 if no error, -ENODEV, -EINVAL otherwise
+ */
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct pxa_udc *udc = the_controller;
+
+        if (!udc)
+                return -ENODEV;
+        if (!driver || driver != udc->driver || !driver->unbind)
+                return -EINVAL;
+
+        stop_activity(udc, driver);
+        udc_disable(udc);
+
+        driver->unbind(&udc->gadget);
+        udc->driver = NULL;
+
+        device_del(&udc->gadget.dev);
+
+        dev_info(udc->dev, "unregistered gadget driver '%s'\n",
+                 driver->driver.name);
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+/**
+ * handle_ep0_ctrl_req - handle control endpoint control request
+ * @udc: udc device
+ * @req: control request
+ */
+static void handle_ep0_ctrl_req(struct pxa_udc *udc,
+                                struct pxa27x_request *req)
+{
+        struct pxa_ep *ep = &udc->pxa_ep[0];
+        union {
+                struct usb_ctrlrequest  r;
+                u32                     word[2];
+        } u;
+        int i;
+        int have_extrabytes = 0;
+
+        nuke(ep, -EPROTO);
+
+        /* read SETUP packet */
+        for (i = 0; i < 2; i++) {
+                if (unlikely(ep_is_empty(ep)))
+                        goto stall;
+                u.word[i] = udc_ep_readl(ep, UDCDR);
+        }
+
+        have_extrabytes = !ep_is_empty(ep);
+        while (!ep_is_empty(ep)) {
+                i = udc_ep_readl(ep, UDCDR);
+                ep_err(ep, "wrong to have extra bytes for setup : 0x%08x\n", i);
+        }
+
+        ep_dbg(ep, "SETUP %02x.%02x v%04x i%04x l%04x\n",
+                u.r.bRequestType, u.r.bRequest,
+                le16_to_cpu(u.r.wValue), le16_to_cpu(u.r.wIndex),
+                le16_to_cpu(u.r.wLength));
+        if (unlikely(have_extrabytes))
+                goto stall;
+
+        if (u.r.bRequestType & USB_DIR_IN)
+                set_ep0state(udc, IN_DATA_STAGE);
+        else
+                set_ep0state(udc, OUT_DATA_STAGE);
+
+        /* Tell UDC to enter Data Stage */
+        udc_ep_writel(ep, UDCCSR, UDCCSR0_SA | UDCCSR0_OPC);
+
+        i = udc->driver->setup(&udc->gadget, &u.r);
+        if (i < 0)
+                goto stall;
+out:
+        return;
+stall:
+        ep_dbg(ep, "protocol STALL, udccsr0=%03x err %d\n",
+                udc_ep_readl(ep, UDCCSR), i);
+        udc_ep_writel(ep, UDCCSR, UDCCSR0_FST | UDCCSR0_FTF);
+        set_ep0state(udc, STALL);
+        goto out;
+}
+
+/**
+ * handle_ep0 - Handle control endpoint data transfers
+ * @udc: udc device
+ * @fifo_irq: 1 if triggered by fifo service type irq
+ * @opc_irq: 1 if triggered by output packet complete type irq
+ *
+ * Context : when in_interrupt() or with ep->lock held
+ *
+ * Tries to transfer all pending request data into the endpoint and/or
+ * transfer all pending data in the endpoint into usb requests.
+ * Handles states of ep0 automata.
+ *
+ * PXA27x hardware handles several standard usb control requests without
+ * driver notification.  The requests fully handled by hardware are :
+ *  SET_ADDRESS, SET_FEATURE, CLEAR_FEATURE, GET_CONFIGURATION, GET_INTERFACE,
+ *  GET_STATUS
+ * The requests handled by hardware, but with irq notification are :
+ *  SYNCH_FRAME, SET_CONFIGURATION, SET_INTERFACE
+ * The remaining standard requests really handled by handle_ep0 are :
+ *  GET_DESCRIPTOR, SET_DESCRIPTOR, specific requests.
+ * Requests standardized outside of USB 2.0 chapter 9 are handled more
+ * uniformly, by gadget drivers.
+ *
+ * The control endpoint state machine is _not_ USB spec compliant, it's even
+ * hardly compliant with Intel PXA270 developers guide.
+ * The key points which inferred this state machine are :
+ *   - on every setup token, bit UDCCSR0_SA is raised and held until cleared by
+ *     software.
+ *   - on every OUT packet received, UDCCSR0_OPC is raised and held until
+ *     cleared by software.
+ *   - clearing UDCCSR0_OPC always flushes ep0. If in setup stage, never do it
+ *     before reading ep0.
+ *   - irq can be called on a "packet complete" event (opc_irq=1), while
+ *     UDCCSR0_OPC is not yet raised (delta can be as big as 100ms
+ *     from experimentation).
+ *   - as UDCCSR0_SA can be activated while in irq handling, and clearing
+ *     UDCCSR0_OPC would flush the setup data, we almost never clear UDCCSR0_OPC
+ *     => we never actually read the "status stage" packet of an IN data stage
+ *     => this is not documented in Intel documentation
+ *   - hardware as no idea of STATUS STAGE, it only handle SETUP STAGE and DATA
+ *     STAGE. The driver add STATUS STAGE to send last zero length packet in
+ *     OUT_STATUS_STAGE.
+ *   - special attention was needed for IN_STATUS_STAGE. If a packet complete
+ *     event is detected, we terminate the status stage without ackowledging the
+ *     packet (not to risk to loose a potential SETUP packet)
+ */
+static void handle_ep0(struct pxa_udc *udc, int fifo_irq, int opc_irq)
+{
+        u32                     udccsr0;
+        struct pxa_ep           *ep = &udc->pxa_ep[0];
+        struct pxa27x_request   *req = NULL;
+        int                     completed = 0;
+
+        udccsr0 = udc_ep_readl(ep, UDCCSR);
+        ep_dbg(ep, "state=%s, req=%p, udccsr0=0x%03x, udcbcr=%d, irq_msk=%x\n",
+                EP0_STNAME(udc), req, udccsr0, udc_ep_readl(ep, UDCBCR),
+                (fifo_irq << 1 | opc_irq));
+
+        if (!list_empty(&ep->queue))
+                req = list_entry(ep->queue.next, struct pxa27x_request, queue);
+
+        if (udccsr0 & UDCCSR0_SST) {
+                ep_dbg(ep, "clearing stall status\n");
+                nuke(ep, -EPIPE);
+                udc_ep_writel(ep, UDCCSR, UDCCSR0_SST);
+                ep0_idle(udc);
+        }
+
+        if (udccsr0 & UDCCSR0_SA) {
+                nuke(ep, 0);
+                set_ep0state(udc, SETUP_STAGE);
+        }
+
+        switch (udc->ep0state) {
+        case WAIT_FOR_SETUP:
+                /*
+                 * Hardware bug : beware, we cannot clear OPC, since we would
+                 * miss a potential OPC irq for a setup packet.
+                 * So, we only do ... nothing, and hope for a next irq with
+                 * UDCCSR0_SA set.
+                 */
+                break;
+        case SETUP_STAGE:
+                udccsr0 &= UDCCSR0_CTRL_REQ_MASK;
+                if (likely(udccsr0 == UDCCSR0_CTRL_REQ_MASK))
+                        handle_ep0_ctrl_req(udc, req);
+                break;
+        case IN_DATA_STAGE:                     /* GET_DESCRIPTOR */
+                if (epout_has_pkt(ep))
+                        udc_ep_writel(ep, UDCCSR, UDCCSR0_OPC);
+                if (req && !ep_is_full(ep))
+                        completed = write_ep0_fifo(ep, req);
+                if (completed)
+                        ep0_end_in_req(ep, req);
+                break;
+        case OUT_DATA_STAGE:                    /* SET_DESCRIPTOR */
+                if (epout_has_pkt(ep) && req)
+                        completed = read_ep0_fifo(ep, req);
+                if (completed)
+                        ep0_end_out_req(ep, req);
+                break;
+        case STALL:
+                udc_ep_writel(ep, UDCCSR, UDCCSR0_FST);
+                break;
+        case IN_STATUS_STAGE:
+                /*
+                 * Hardware bug : beware, we cannot clear OPC, since we would
+                 * miss a potential PC irq for a setup packet.
+                 * So, we only put the ep0 into WAIT_FOR_SETUP state.
+                 */
+                if (opc_irq)
+                        ep0_idle(udc);
+                break;
+        case OUT_STATUS_STAGE:
+        case WAIT_ACK_SET_CONF_INTERF:
+                ep_warn(ep, "should never get in %s state here!!!\n",
+                                EP0_STNAME(ep->dev));
+                ep0_idle(udc);
+                break;
+        }
+}
+
+/**
+ * handle_ep - Handle endpoint data tranfers
+ * @ep: pxa physical endpoint
+ *
+ * Tries to transfer all pending request data into the endpoint and/or
+ * transfer all pending data in the endpoint into usb requests.
+ *
+ * Is always called when in_interrupt() or with ep->lock held.
+ */
+static void handle_ep(struct pxa_ep *ep)
+{
+        struct pxa27x_request   *req;
+        int completed;
+        u32 udccsr;
+        int is_in = ep->dir_in;
+        int loop = 0;
+
+        do {
+                completed = 0;
+                udccsr = udc_ep_readl(ep, UDCCSR);
+                if (likely(!list_empty(&ep->queue)))
+                        req = list_entry(ep->queue.next,
+                                        struct pxa27x_request, queue);
+                else
+                        req = NULL;
+
+                ep_dbg(ep, "req:%p, udccsr 0x%03x loop=%d\n",
+                                req, udccsr, loop++);
+
+                if (unlikely(udccsr & (UDCCSR_SST | UDCCSR_TRN)))
+                        udc_ep_writel(ep, UDCCSR,
+                                        udccsr & (UDCCSR_SST | UDCCSR_TRN));
+                if (!req)
+                        break;
+
+                if (unlikely(is_in)) {
+                        if (likely(!ep_is_full(ep)))
+                                completed = write_fifo(ep, req);
+                        if (completed)
+                                ep_end_in_req(ep, req);
+                } else {
+                        if (likely(epout_has_pkt(ep)))
+                                completed = read_fifo(ep, req);
+                        if (completed)
+                                ep_end_out_req(ep, req);
+                }
+        } while (completed);
+}
+
+/**
+ * pxa27x_change_configuration - Handle SET_CONF usb request notification
+ * @udc: udc device
+ * @config: usb configuration
+ *
+ * Post the request to upper level.
+ * Don't use any pxa specific harware configuration capabilities
+ */
+static void pxa27x_change_configuration(struct pxa_udc *udc, int config)
+{
+        struct usb_ctrlrequest req ;
+
+        dev_dbg(udc->dev, "config=%d\n", config);
+
+        udc->config = config;
+        udc->last_interface = 0;
+        udc->last_alternate = 0;
+
+        req.bRequestType = 0;
+        req.bRequest = USB_REQ_SET_CONFIGURATION;
+        req.wValue = config;
+        req.wIndex = 0;
+        req.wLength = 0;
+
+        set_ep0state(udc, WAIT_ACK_SET_CONF_INTERF);
+        udc->driver->setup(&udc->gadget, &req);
+}
+
+/**
+ * pxa27x_change_interface - Handle SET_INTERF usb request notification
+ * @udc: udc device
+ * @iface: interface number
+ * @alt: alternate setting number
+ *
+ * Post the request to upper level.
+ * Don't use any pxa specific harware configuration capabilities
+ */
+static void pxa27x_change_interface(struct pxa_udc *udc, int iface, int alt)
+{
+        struct usb_ctrlrequest  req;
+
+        dev_dbg(udc->dev, "interface=%d, alternate setting=%d\n", iface, alt);
+
+        udc->last_interface = iface;
+        udc->last_alternate = alt;
+
+        req.bRequestType = USB_RECIP_INTERFACE;
+        req.bRequest = USB_REQ_SET_INTERFACE;
+        req.wValue = alt;
+        req.wIndex = iface;
+        req.wLength = 0;
+
+        set_ep0state(udc, WAIT_ACK_SET_CONF_INTERF);
+        udc->driver->setup(&udc->gadget, &req);
+}
+
+/*
+ * irq_handle_data - Handle data transfer
+ * @irq: irq IRQ number
+ * @udc: dev pxa_udc device structure
+ *
+ * Called from irq handler, transferts data to or from endpoint to queue
+ */
+static void irq_handle_data(int irq, struct pxa_udc *udc)
+{
+        int i;
+        struct pxa_ep *ep;
+        u32 udcisr0 = udc_readl(udc, UDCISR0) & UDCCISR0_EP_MASK;
+        u32 udcisr1 = udc_readl(udc, UDCISR1) & UDCCISR1_EP_MASK;
+
+        if (udcisr0 & UDCISR_INT_MASK) {
+                udc->pxa_ep[0].stats.irqs++;
+                udc_writel(udc, UDCISR0, UDCISR_INT(0, UDCISR_INT_MASK));
+                handle_ep0(udc, !!(udcisr0 & UDCICR_FIFOERR),
+                                !!(udcisr0 & UDCICR_PKTCOMPL));
+        }
+
+        udcisr0 >>= 2;
+        for (i = 1; udcisr0 != 0 && i < 16; udcisr0 >>= 2, i++) {
+                if (!(udcisr0 & UDCISR_INT_MASK))
+                        continue;
+
+                udc_writel(udc, UDCISR0, UDCISR_INT(i, UDCISR_INT_MASK));
+                ep = &udc->pxa_ep[i];
+                ep->stats.irqs++;
+                handle_ep(ep);
+        }
+
+        for (i = 16; udcisr1 != 0 && i < 24; udcisr1 >>= 2, i++) {
+                udc_writel(udc, UDCISR1, UDCISR_INT(i - 16, UDCISR_INT_MASK));
+                if (!(udcisr1 & UDCISR_INT_MASK))
+                        continue;
+
+                ep = &udc->pxa_ep[i];
+                ep->stats.irqs++;
+                handle_ep(ep);
+        }
+
+}
+
+/**
+ * irq_udc_suspend - Handle IRQ "UDC Suspend"
+ * @udc: udc device
+ */
+static void irq_udc_suspend(struct pxa_udc *udc)
+{
+        udc_writel(udc, UDCISR1, UDCISR1_IRSU);
+        udc->stats.irqs_suspend++;
+
+        if (udc->gadget.speed != USB_SPEED_UNKNOWN
+                        && udc->driver && udc->driver->suspend)
+                udc->driver->suspend(&udc->gadget);
+        ep0_idle(udc);
+}
+
+/**
+  * irq_udc_resume - Handle IRQ "UDC Resume"
+  * @udc: udc device
+  */
+static void irq_udc_resume(struct pxa_udc *udc)
+{
+        udc_writel(udc, UDCISR1, UDCISR1_IRRU);
+        udc->stats.irqs_resume++;
+
+        if (udc->gadget.speed != USB_SPEED_UNKNOWN
+                        && udc->driver && udc->driver->resume)
+                udc->driver->resume(&udc->gadget);
+}
+
+/**
+ * irq_udc_reconfig - Handle IRQ "UDC Change Configuration"
+ * @udc: udc device
+ */
+static void irq_udc_reconfig(struct pxa_udc *udc)
+{
+        unsigned config, interface, alternate, config_change;
+        u32 udccr = udc_readl(udc, UDCCR);
+
+        udc_writel(udc, UDCISR1, UDCISR1_IRCC);
+        udc->stats.irqs_reconfig++;
+
+        config = (udccr & UDCCR_ACN) >> UDCCR_ACN_S;
+        config_change = (config != udc->config);
+        pxa27x_change_configuration(udc, config);
+
+        interface = (udccr & UDCCR_AIN) >> UDCCR_AIN_S;
+        alternate = (udccr & UDCCR_AAISN) >> UDCCR_AAISN_S;
+        pxa27x_change_interface(udc, interface, alternate);
+
+        if (config_change)
+                update_pxa_ep_matches(udc);
+        udc_set_mask_UDCCR(udc, UDCCR_SMAC);
+}
+
+/**
+ * irq_udc_reset - Handle IRQ "UDC Reset"
+ * @udc: udc device
+ */
+static void irq_udc_reset(struct pxa_udc *udc)
+{
+        u32 udccr = udc_readl(udc, UDCCR);
+        struct pxa_ep *ep = &udc->pxa_ep[0];
+
+        dev_info(udc->dev, "USB reset\n");
+        udc_writel(udc, UDCISR1, UDCISR1_IRRS);
+        udc->stats.irqs_reset++;
+
+        if ((udccr & UDCCR_UDA) == 0) {
+                dev_dbg(udc->dev, "USB reset start\n");
+                stop_activity(udc, udc->driver);
+        }
+        udc->gadget.speed = USB_SPEED_FULL;
+        memset(&udc->stats, 0, sizeof udc->stats);
+
+        nuke(ep, -EPROTO);
+        udc_ep_writel(ep, UDCCSR, UDCCSR0_FTF | UDCCSR0_OPC);
+        ep0_idle(udc);
+}
+
+/**
+ * pxa_udc_irq - Main irq handler
+ * @irq: irq number
+ * @_dev: udc device
+ *
+ * Handles all udc interrupts
+ */
+static irqreturn_t pxa_udc_irq(int irq, void *_dev)
+{
+        struct pxa_udc *udc = _dev;
+        u32 udcisr0 = udc_readl(udc, UDCISR0);
+        u32 udcisr1 = udc_readl(udc, UDCISR1);
+        u32 udccr = udc_readl(udc, UDCCR);
+        u32 udcisr1_spec;
+
+        dev_vdbg(udc->dev, "Interrupt, UDCISR0:0x%08x, UDCISR1:0x%08x, "
+                 "UDCCR:0x%08x\n", udcisr0, udcisr1, udccr);
+
+        udcisr1_spec = udcisr1 & 0xf8000000;
+        if (unlikely(udcisr1_spec & UDCISR1_IRSU))
+                irq_udc_suspend(udc);
+        if (unlikely(udcisr1_spec & UDCISR1_IRRU))
+                irq_udc_resume(udc);
+        if (unlikely(udcisr1_spec & UDCISR1_IRCC))
+                irq_udc_reconfig(udc);
+        if (unlikely(udcisr1_spec & UDCISR1_IRRS))
+                irq_udc_reset(udc);
+
+        if ((udcisr0 & UDCCISR0_EP_MASK) | (udcisr1 & UDCCISR1_EP_MASK))
+                irq_handle_data(irq, udc);
+
+        return IRQ_HANDLED;
+}
+
+static struct pxa_udc memory = {
+        .gadget = {
+                .ops            = &pxa_udc_ops,
+                .ep0            = &memory.udc_usb_ep[0].usb_ep,
+                .name           = driver_name,
+                .dev = {
+                        .bus_id         = "gadget",
+                },
+        },
+
+        .udc_usb_ep = {
+                USB_EP_CTRL,
+                USB_EP_OUT_BULK(1),
+                USB_EP_IN_BULK(2),
+                USB_EP_IN_ISO(3),
+                USB_EP_OUT_ISO(4),
+                USB_EP_IN_INT(5),
+        },
+
+        .pxa_ep = {
+                PXA_EP_CTRL,
+                /* Endpoints for gadget zero */
+                PXA_EP_OUT_BULK(1, 1, 3, 0, 0),
+                PXA_EP_IN_BULK(2,  2, 3, 0, 0),
+                /* Endpoints for ether gadget, file storage gadget */
+                PXA_EP_OUT_BULK(3, 1, 1, 0, 0),
+                PXA_EP_IN_BULK(4,  2, 1, 0, 0),
+                PXA_EP_IN_ISO(5,   3, 1, 0, 0),
+                PXA_EP_OUT_ISO(6,  4, 1, 0, 0),
+                PXA_EP_IN_INT(7,   5, 1, 0, 0),
+                /* Endpoints for RNDIS, serial */
+                PXA_EP_OUT_BULK(8, 1, 2, 0, 0),
+                PXA_EP_IN_BULK(9,  2, 2, 0, 0),
+                PXA_EP_IN_INT(10,  5, 2, 0, 0),
+                /*
+                 * All the following endpoints are only for completion.  They
+                 * won't never work, as multiple interfaces are really broken on
+                 * the pxa.
+                */
+                PXA_EP_OUT_BULK(11, 1, 2, 1, 0),
+                PXA_EP_IN_BULK(12,  2, 2, 1, 0),
+                /* Endpoint for CDC Ether */
+                PXA_EP_OUT_BULK(13, 1, 1, 1, 1),
+                PXA_EP_IN_BULK(14,  2, 1, 1, 1),
+        }
+};
+
+/**
+ * pxa_udc_probe - probes the udc device
+ * @_dev: platform device
+ *
+ * Perform basic init : allocates udc clock, creates sysfs files, requests
+ * irq.
+ */
+static int __init pxa_udc_probe(struct platform_device *pdev)
+{
+        struct resource *regs;
+        struct pxa_udc *udc = &memory;
+        int retval;
+
+        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!regs)
+                return -ENXIO;
+        udc->irq = platform_get_irq(pdev, 0);
+        if (udc->irq < 0)
+                return udc->irq;
+
+        udc->dev = &pdev->dev;
+        udc->mach = pdev->dev.platform_data;
+
+        udc->clk = clk_get(&pdev->dev, "UDCCLK");
+        if (IS_ERR(udc->clk)) {
+                retval = PTR_ERR(udc->clk);
+                goto err_clk;
+        }
+
+        retval = -ENOMEM;
+        udc->regs = ioremap(regs->start, regs->end - regs->start + 1);
+        if (!udc->regs) {
+                dev_err(&pdev->dev, "Unable to map UDC I/O memory\n");
+                goto err_map;
+        }
+
+        device_initialize(&udc->gadget.dev);
+        udc->gadget.dev.parent = &pdev->dev;
+        udc->gadget.dev.dma_mask = NULL;
+
+        the_controller = udc;
+        platform_set_drvdata(pdev, udc);
+        udc_init_data(udc);
+        pxa_eps_setup(udc);
+
+        /* irq setup after old hardware state is cleaned up */
+        retval = request_irq(udc->irq, pxa_udc_irq,
+                        IRQF_SHARED, driver_name, udc);
+        if (retval != 0) {
+                dev_err(udc->dev, "%s: can't get irq %i, err %d\n",
+                        driver_name, IRQ_USB, retval);
+                goto err_irq;
+        }
+
+        pxa_init_debugfs(udc);
+        return 0;
+err_irq:
+        iounmap(udc->regs);
+err_map:
+        clk_put(udc->clk);
+        udc->clk = NULL;
+err_clk:
+        return retval;
+}
+
+/**
+ * pxa_udc_remove - removes the udc device driver
+ * @_dev: platform device
+ */
+static int __exit pxa_udc_remove(struct platform_device *_dev)
+{
+        struct pxa_udc *udc = platform_get_drvdata(_dev);
+
+        usb_gadget_unregister_driver(udc->driver);
+        free_irq(udc->irq, udc);
+        pxa_cleanup_debugfs(udc);
+
+        platform_set_drvdata(_dev, NULL);
+        the_controller = NULL;
+        clk_put(udc->clk);
+
+        return 0;
+}
+
+static void pxa_udc_shutdown(struct platform_device *_dev)
+{
+        struct pxa_udc *udc = platform_get_drvdata(_dev);
+
+        if (udc_readl(udc, UDCCR) & UDCCR_UDE)
+                udc_disable(udc);
+}
+
+#ifdef CONFIG_PM
+/**
+ * pxa_udc_suspend - Suspend udc device
+ * @_dev: platform device
+ * @state: suspend state
+ *
+ * Suspends udc : saves configuration registers (UDCCR*), then disables the udc
+ * device.
+ */
+static int pxa_udc_suspend(struct platform_device *_dev, pm_message_t state)
+{
+        int i;
+        struct pxa_udc *udc = platform_get_drvdata(_dev);
+        struct pxa_ep *ep;
+
+        ep = &udc->pxa_ep[0];
+        udc->udccsr0 = udc_ep_readl(ep, UDCCSR);
+        for (i = 1; i < NR_PXA_ENDPOINTS; i++) {
+                ep = &udc->pxa_ep[i];
+                ep->udccsr_value = udc_ep_readl(ep, UDCCSR);
+                ep->udccr_value  = udc_ep_readl(ep, UDCCR);
+                ep_dbg(ep, "udccsr:0x%03x, udccr:0x%x\n",
+                                ep->udccsr_value, ep->udccr_value);
+        }
+
+        udc_disable(udc);
+
+        return 0;
+}
+
+/**
+ * pxa_udc_resume - Resume udc device
+ * @_dev: platform device
+ *
+ * Resumes udc : restores configuration registers (UDCCR*), then enables the udc
+ * device.
+ */
+static int pxa_udc_resume(struct platform_device *_dev)
+{
+        int i;
+        struct pxa_udc *udc = platform_get_drvdata(_dev);
+        struct pxa_ep *ep;
+
+        ep = &udc->pxa_ep[0];
+        udc_ep_writel(ep, UDCCSR, udc->udccsr0 & (UDCCSR0_FST | UDCCSR0_DME));
+        for (i = 1; i < NR_PXA_ENDPOINTS; i++) {
+                ep = &udc->pxa_ep[i];
+                udc_ep_writel(ep, UDCCSR, ep->udccsr_value);
+                udc_ep_writel(ep, UDCCR,  ep->udccr_value);
+                ep_dbg(ep, "udccsr:0x%03x, udccr:0x%x\n",
+                                ep->udccsr_value, ep->udccr_value);
+        }
+
+        udc_enable(udc);
+        /*
+         * We do not handle OTG yet.
+         *
+         * OTGPH bit is set when sleep mode is entered.
+         * it indicates that OTG pad is retaining its state.
+         * Upon exit from sleep mode and before clearing OTGPH,
+         * Software must configure the USB OTG pad, UDC, and UHC
+         * to the state they were in before entering sleep mode.
+         */
+        PSSR |= PSSR_OTGPH;
+
+        return 0;
+}
+#endif
+
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:pxa2xx-udc");
+
+static struct platform_driver udc_driver = {
+        .driver         = {
+                .name   = "pxa2xx-udc",
+                .owner  = THIS_MODULE,
+        },
+        .remove         = __exit_p(pxa_udc_remove),
+        .shutdown       = pxa_udc_shutdown,
+#ifdef CONFIG_PM
+        .suspend        = pxa_udc_suspend,
+        .resume         = pxa_udc_resume
+#endif
+};
+
+static int __init udc_init(void)
+{
+        if (!cpu_is_pxa27x())
+                return -ENODEV;
+
+        printk(KERN_INFO "%s: version %s\n", driver_name, DRIVER_VERSION);
+        return platform_driver_probe(&udc_driver, pxa_udc_probe);
+}
+module_init(udc_init);
+
+
+static void __exit udc_exit(void)
+{
+        platform_driver_unregister(&udc_driver);
+}
+module_exit(udc_exit);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Robert Jarzmik");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/gadget/pxa27x_udc.h b/drivers/usb/gadget/pxa27x_udc.h
new file mode 100644
index 000000000000..97453db924ff
--- /dev/null
+++ b/drivers/usb/gadget/pxa27x_udc.h
@@ -0,0 +1,495 @@
+/*
+ * linux/drivers/usb/gadget/pxa27x_udc.h
+ * Intel PXA27x on-chip full speed USB device controller
+ *
+ * Inspired by original driver by Frank Becker, David Brownell, and others.
+ * Copyright (C) 2008 Robert Jarzmik
+ *
+ * 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
+ */
+
+#ifndef __LINUX_USB_GADGET_PXA27X_H
+#define __LINUX_USB_GADGET_PXA27X_H
+
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/io.h>
+
+/*
+ * Register definitions
+ */
+/* Offsets */
+#define UDCCR           0x0000          /* UDC Control Register */
+#define UDCICR0         0x0004          /* UDC Interrupt Control Register0 */
+#define UDCICR1         0x0008          /* UDC Interrupt Control Register1 */
+#define UDCISR0         0x000C          /* UDC Interrupt Status Register 0 */
+#define UDCISR1         0x0010          /* UDC Interrupt Status Register 1 */
+#define UDCFNR          0x0014          /* UDC Frame Number Register */
+#define UDCOTGICR       0x0018          /* UDC On-The-Go interrupt control */
+#define UP2OCR          0x0020          /* USB Port 2 Output Control register */
+#define UP3OCR          0x0024          /* USB Port 3 Output Control register */
+#define UDCCSRn(x)      (0x0100 + ((x)<<2)) /* UDC Control/Status register */
+#define UDCBCRn(x)      (0x0200 + ((x)<<2)) /* UDC Byte Count Register */
+#define UDCDRn(x)       (0x0300 + ((x)<<2)) /* UDC Data Register  */
+#define UDCCRn(x)       (0x0400 + ((x)<<2)) /* UDC Control Register */
+
+#define UDCCR_OEN       (1 << 31)       /* On-the-Go Enable */
+#define UDCCR_AALTHNP   (1 << 30)       /* A-device Alternate Host Negotiation
+                                           Protocol Port Support */
+#define UDCCR_AHNP      (1 << 29)       /* A-device Host Negotiation Protocol
+                                           Support */
+#define UDCCR_BHNP      (1 << 28)       /* B-device Host Negotiation Protocol
+                                           Enable */
+#define UDCCR_DWRE      (1 << 16)       /* Device Remote Wake-up Enable */
+#define UDCCR_ACN       (0x03 << 11)    /* Active UDC configuration Number */
+#define UDCCR_ACN_S     11
+#define UDCCR_AIN       (0x07 << 8)     /* Active UDC interface Number */
+#define UDCCR_AIN_S     8
+#define UDCCR_AAISN     (0x07 << 5)     /* Active UDC Alternate Interface
+                                           Setting Number */
+#define UDCCR_AAISN_S   5
+#define UDCCR_SMAC      (1 << 4)        /* Switch Endpoint Memory to Active
+                                           Configuration */
+#define UDCCR_EMCE      (1 << 3)        /* Endpoint Memory Configuration
+                                           Error */
+#define UDCCR_UDR       (1 << 2)        /* UDC Resume */
+#define UDCCR_UDA       (1 << 1)        /* UDC Active */
+#define UDCCR_UDE       (1 << 0)        /* UDC Enable */
+
+#define UDCICR_INT(n, intr) (((intr) & 0x03) << (((n) & 0x0F) * 2))
+#define UDCICR1_IECC    (1 << 31)       /* IntEn - Configuration Change */
+#define UDCICR1_IESOF   (1 << 30)       /* IntEn - Start of Frame */
+#define UDCICR1_IERU    (1 << 29)       /* IntEn - Resume */
+#define UDCICR1_IESU    (1 << 28)       /* IntEn - Suspend */
+#define UDCICR1_IERS    (1 << 27)       /* IntEn - Reset */
+#define UDCICR_FIFOERR  (1 << 1)        /* FIFO Error interrupt for EP */
+#define UDCICR_PKTCOMPL (1 << 0)        /* Packet Complete interrupt for EP */
+#define UDCICR_INT_MASK (UDCICR_FIFOERR | UDCICR_PKTCOMPL)
+
+#define UDCISR_INT(n, intr) (((intr) & 0x03) << (((n) & 0x0F) * 2))
+#define UDCISR1_IRCC    (1 << 31)       /* IntReq - Configuration Change */
+#define UDCISR1_IRSOF   (1 << 30)       /* IntReq - Start of Frame */
+#define UDCISR1_IRRU    (1 << 29)       /* IntReq - Resume */
+#define UDCISR1_IRSU    (1 << 28)       /* IntReq - Suspend */
+#define UDCISR1_IRRS    (1 << 27)       /* IntReq - Reset */
+#define UDCISR_INT_MASK (UDCICR_FIFOERR | UDCICR_PKTCOMPL)
+
+#define UDCOTGICR_IESF  (1 << 24)       /* OTG SET_FEATURE command recvd */
+#define UDCOTGICR_IEXR  (1 << 17)       /* Extra Transciever Interrupt
+                                           Rising Edge Interrupt Enable */
+#define UDCOTGICR_IEXF  (1 << 16)       /* Extra Transciever Interrupt
+                                           Falling Edge Interrupt Enable */
+#define UDCOTGICR_IEVV40R (1 << 9)      /* OTG Vbus Valid 4.0V Rising Edge
+                                           Interrupt Enable */
+#define UDCOTGICR_IEVV40F (1 << 8)      /* OTG Vbus Valid 4.0V Falling Edge
+                                           Interrupt Enable */
+#define UDCOTGICR_IEVV44R (1 << 7)      /* OTG Vbus Valid 4.4V Rising Edge
+                                           Interrupt Enable */
+#define UDCOTGICR_IEVV44F (1 << 6)      /* OTG Vbus Valid 4.4V Falling Edge
+                                           Interrupt Enable */
+#define UDCOTGICR_IESVR (1 << 5)        /* OTG Session Valid Rising Edge
+                                           Interrupt Enable */
+#define UDCOTGICR_IESVF (1 << 4)        /* OTG Session Valid Falling Edge
+                                           Interrupt Enable */
+#define UDCOTGICR_IESDR (1 << 3)        /* OTG A-Device SRP Detect Rising
+                                           Edge Interrupt Enable */
+#define UDCOTGICR_IESDF (1 << 2)        /* OTG A-Device SRP Detect Falling
+                                           Edge Interrupt Enable */
+#define UDCOTGICR_IEIDR (1 << 1)        /* OTG ID Change Rising Edge
+                                           Interrupt Enable */
+#define UDCOTGICR_IEIDF (1 << 0)        /* OTG ID Change Falling Edge
+                                           Interrupt Enable */
+
+/* Host Port 2 field bits */
+#define UP2OCR_CPVEN    (1 << 0)        /* Charge Pump Vbus Enable */
+#define UP2OCR_CPVPE    (1 << 1)        /* Charge Pump Vbus Pulse Enable */
+                                        /* Transceiver enablers */
+#define UP2OCR_DPPDE    (1 << 2)        /*   D+ Pull Down Enable */
+#define UP2OCR_DMPDE    (1 << 3)        /*   D- Pull Down Enable */
+#define UP2OCR_DPPUE    (1 << 4)        /*   D+ Pull Up Enable */
+#define UP2OCR_DMPUE    (1 << 5)        /*   D- Pull Up Enable */
+#define UP2OCR_DPPUBE   (1 << 6)        /*   D+ Pull Up Bypass Enable */
+#define UP2OCR_DMPUBE   (1 << 7)        /*   D- Pull Up Bypass Enable */
+#define UP2OCR_EXSP     (1 << 8)        /* External Transceiver Speed Control */
+#define UP2OCR_EXSUS    (1 << 9)        /* External Transceiver Speed Enable */
+#define UP2OCR_IDON     (1 << 10)       /* OTG ID Read Enable */
+#define UP2OCR_HXS      (1 << 16)       /* Transceiver Output Select */
+#define UP2OCR_HXOE     (1 << 17)       /* Transceiver Output Enable */
+#define UP2OCR_SEOS     (1 << 24)       /* Single-Ended Output Select */
+
+#define UDCCSR0_SA      (1 << 7)        /* Setup Active */
+#define UDCCSR0_RNE     (1 << 6)        /* Receive FIFO Not Empty */
+#define UDCCSR0_FST     (1 << 5)        /* Force Stall */
+#define UDCCSR0_SST     (1 << 4)        /* Sent Stall */
+#define UDCCSR0_DME     (1 << 3)        /* DMA Enable */
+#define UDCCSR0_FTF     (1 << 2)        /* Flush Transmit FIFO */
+#define UDCCSR0_IPR     (1 << 1)        /* IN Packet Ready */
+#define UDCCSR0_OPC     (1 << 0)        /* OUT Packet Complete */
+
+#define UDCCSR_DPE      (1 << 9)        /* Data Packet Error */
+#define UDCCSR_FEF      (1 << 8)        /* Flush Endpoint FIFO */
+#define UDCCSR_SP       (1 << 7)        /* Short Packet Control/Status */
+#define UDCCSR_BNE      (1 << 6)        /* Buffer Not Empty (IN endpoints) */
+#define UDCCSR_BNF      (1 << 6)        /* Buffer Not Full (OUT endpoints) */
+#define UDCCSR_FST      (1 << 5)        /* Force STALL */
+#define UDCCSR_SST      (1 << 4)        /* Sent STALL */
+#define UDCCSR_DME      (1 << 3)        /* DMA Enable */
+#define UDCCSR_TRN      (1 << 2)        /* Tx/Rx NAK */
+#define UDCCSR_PC       (1 << 1)        /* Packet Complete */
+#define UDCCSR_FS       (1 << 0)        /* FIFO needs service */
+
+#define UDCCONR_CN      (0x03 << 25)    /* Configuration Number */
+#define UDCCONR_CN_S    25
+#define UDCCONR_IN      (0x07 << 22)    /* Interface Number */
+#define UDCCONR_IN_S    22
+#define UDCCONR_AISN    (0x07 << 19)    /* Alternate Interface Number */
+#define UDCCONR_AISN_S  19
+#define UDCCONR_EN      (0x0f << 15)    /* Endpoint Number */
+#define UDCCONR_EN_S    15
+#define UDCCONR_ET      (0x03 << 13)    /* Endpoint Type: */
+#define UDCCONR_ET_S    13
+#define UDCCONR_ET_INT  (0x03 << 13)    /*   Interrupt */
+#define UDCCONR_ET_BULK (0x02 << 13)    /*   Bulk */
+#define UDCCONR_ET_ISO  (0x01 << 13)    /*   Isochronous */
+#define UDCCONR_ET_NU   (0x00 << 13)    /*   Not used */
+#define UDCCONR_ED      (1 << 12)       /* Endpoint Direction */
+#define UDCCONR_MPS     (0x3ff << 2)    /* Maximum Packet Size */
+#define UDCCONR_MPS_S   2
+#define UDCCONR_DE      (1 << 1)        /* Double Buffering Enable */
+#define UDCCONR_EE      (1 << 0)        /* Endpoint Enable */
+
+#define UDCCR_MASK_BITS (UDCCR_OEN | UDCCR_SMAC | UDCCR_UDR | UDCCR_UDE)
+#define UDCCSR_WR_MASK  (UDCCSR_DME | UDCCSR_FST)
+#define UDC_FNR_MASK    (0x7ff)
+#define UDC_BCR_MASK    (0x3ff)
+
+/*
+ * UDCCR = UDC Endpoint Configuration Registers
+ * UDCCSR = UDC Control/Status Register for this EP
+ * UDCBCR = UDC Byte Count Remaining (contents of OUT fifo)
+ * UDCDR = UDC Endpoint Data Register (the fifo)
+ */
+#define ofs_UDCCR(ep)   (UDCCRn(ep->idx))
+#define ofs_UDCCSR(ep)  (UDCCSRn(ep->idx))
+#define ofs_UDCBCR(ep)  (UDCBCRn(ep->idx))
+#define ofs_UDCDR(ep)   (UDCDRn(ep->idx))
+
+/* Register access macros */
+#define udc_ep_readl(ep, reg)   \
+        __raw_readl((ep)->dev->regs + ofs_##reg(ep))
+#define udc_ep_writel(ep, reg, value)   \
+        __raw_writel((value), ep->dev->regs + ofs_##reg(ep))
+#define udc_ep_readb(ep, reg)   \
+        __raw_readb((ep)->dev->regs + ofs_##reg(ep))
+#define udc_ep_writeb(ep, reg, value)   \
+        __raw_writeb((value), ep->dev->regs + ofs_##reg(ep))
+#define udc_readl(dev, reg)     \
+        __raw_readl((dev)->regs + (reg))
+#define udc_writel(udc, reg, value)     \
+        __raw_writel((value), (udc)->regs + (reg))
+
+#define UDCCSR_MASK             (UDCCSR_FST | UDCCSR_DME)
+#define UDCCISR0_EP_MASK        ~0
+#define UDCCISR1_EP_MASK        0xffff
+#define UDCCSR0_CTRL_REQ_MASK   (UDCCSR0_OPC | UDCCSR0_SA | UDCCSR0_RNE)
+
+#define EPIDX(ep)       (ep->idx)
+#define EPADDR(ep)      (ep->addr)
+#define EPXFERTYPE(ep)  (ep->type)
+#define EPNAME(ep)      (ep->name)
+#define is_ep0(ep)      (!ep->idx)
+#define EPXFERTYPE_is_ISO(ep) (EPXFERTYPE(ep) == USB_ENDPOINT_XFER_ISOC)
+
+/*
+ * Endpoint definitions
+ *
+ * Once enabled, pxa endpoint configuration is freezed, and cannot change
+ * unless a reset happens or the udc is disabled.
+ * Therefore, we must define all pxa potential endpoint definitions needed for
+ * all gadget and set them up before the udc is enabled.
+ *
+ * As the architecture chosen is fully static, meaning the pxa endpoint
+ * configurations are set up once and for all, we must provide a way to match
+ * one usb endpoint (usb_ep) to several pxa endpoints. The reason is that gadget
+ * layer autoconf doesn't choose the usb_ep endpoint on (config, interface, alt)
+ * criteria, while the pxa architecture requires that.
+ *
+ * The solution is to define several pxa endpoints matching one usb_ep. Ex:
+ *   - "ep1-in" matches pxa endpoint EPA (which is an IN ep at addr 1, when
+ *     the udc talks on (config=3, interface=0, alt=0)
+ *   - "ep1-in" matches pxa endpoint EPB (which is an IN ep at addr 1, when
+ *     the udc talks on (config=3, interface=0, alt=1)
+ *   - "ep1-in" matches pxa endpoint EPC (which is an IN ep at addr 1, when
+ *     the udc talks on (config=2, interface=0, alt=0)
+ *
+ * We'll define the pxa endpoint by its index (EPA => idx=1, EPB => idx=2, ...)
+ */
+
+/*
+ * Endpoint definition helpers
+ */
+#define USB_EP_DEF(addr, bname, dir, type, maxpkt) \
+{ .usb_ep = { .name = bname, .ops = &pxa_ep_ops, .maxpacket = maxpkt, }, \
+  .desc = {     .bEndpointAddress = addr | (dir ? USB_DIR_IN : 0), \
+                .bmAttributes = type, \
+                .wMaxPacketSize = maxpkt, }, \
+  .dev = &memory \
+}
+#define USB_EP_BULK(addr, bname, dir) \
+  USB_EP_DEF(addr, bname, dir, USB_ENDPOINT_XFER_BULK, BULK_FIFO_SIZE)
+#define USB_EP_ISO(addr, bname, dir) \
+  USB_EP_DEF(addr, bname, dir, USB_ENDPOINT_XFER_ISOC, ISO_FIFO_SIZE)
+#define USB_EP_INT(addr, bname, dir) \
+  USB_EP_DEF(addr, bname, dir, USB_ENDPOINT_XFER_INT, INT_FIFO_SIZE)
+#define USB_EP_IN_BULK(n)       USB_EP_BULK(n, "ep" #n "in-bulk", 1)
+#define USB_EP_OUT_BULK(n)      USB_EP_BULK(n, "ep" #n "out-bulk", 0)
+#define USB_EP_IN_ISO(n)        USB_EP_ISO(n,  "ep" #n "in-iso", 1)
+#define USB_EP_OUT_ISO(n)       USB_EP_ISO(n,  "ep" #n "out-iso", 0)
+#define USB_EP_IN_INT(n)        USB_EP_INT(n,  "ep" #n "in-int", 1)
+#define USB_EP_CTRL             USB_EP_DEF(0,  "ep0", 0, 0, EP0_FIFO_SIZE)
+
+#define PXA_EP_DEF(_idx, _addr, dir, _type, maxpkt, _config, iface, altset) \
+{ \
+        .dev = &memory, \
+        .name = "ep" #_idx, \
+        .idx = _idx, .enabled = 0, \
+        .dir_in = dir, .addr = _addr, \
+        .config = _config, .interface = iface, .alternate = altset, \
+        .type = _type, .fifo_size = maxpkt, \
+}
+#define PXA_EP_BULK(_idx, addr, dir, config, iface, alt) \
+  PXA_EP_DEF(_idx, addr, dir, USB_ENDPOINT_XFER_BULK, BULK_FIFO_SIZE, \
+                config, iface, alt)
+#define PXA_EP_ISO(_idx, addr, dir, config, iface, alt) \
+  PXA_EP_DEF(_idx, addr, dir, USB_ENDPOINT_XFER_ISOC, ISO_FIFO_SIZE, \
+                config, iface, alt)
+#define PXA_EP_INT(_idx, addr, dir, config, iface, alt) \
+  PXA_EP_DEF(_idx, addr, dir, USB_ENDPOINT_XFER_INT, INT_FIFO_SIZE, \
+                config, iface, alt)
+#define PXA_EP_IN_BULK(i, adr, c, f, a)         PXA_EP_BULK(i, adr, 1, c, f, a)
+#define PXA_EP_OUT_BULK(i, adr, c, f, a)        PXA_EP_BULK(i, adr, 0, c, f, a)
+#define PXA_EP_IN_ISO(i, adr, c, f, a)          PXA_EP_ISO(i, adr, 1, c, f, a)
+#define PXA_EP_OUT_ISO(i, adr, c, f, a)         PXA_EP_ISO(i, adr, 0, c, f, a)
+#define PXA_EP_IN_INT(i, adr, c, f, a)          PXA_EP_INT(i, adr, 1, c, f, a)
+#define PXA_EP_CTRL     PXA_EP_DEF(0, 0, 0, 0, EP0_FIFO_SIZE, 0, 0, 0)
+
+struct pxa27x_udc;
+
+struct stats {
+        unsigned long in_ops;
+        unsigned long out_ops;
+        unsigned long in_bytes;
+        unsigned long out_bytes;
+        unsigned long irqs;
+};
+
+/**
+ * struct udc_usb_ep - container of each usb_ep structure
+ * @usb_ep: usb endpoint
+ * @desc: usb descriptor, especially type and address
+ * @dev: udc managing this endpoint
+ * @pxa_ep: matching pxa_ep (cache of find_pxa_ep() call)
+ */
+struct udc_usb_ep {
+        struct usb_ep usb_ep;
+        struct usb_endpoint_descriptor desc;
+        struct pxa_udc *dev;
+        struct pxa_ep *pxa_ep;
+};
+
+/**
+ * struct pxa_ep - pxa endpoint
+ * @dev: udc device
+ * @queue: requests queue
+ * @lock: lock to pxa_ep data (queues and stats)
+ * @enabled: true when endpoint enabled (not stopped by gadget layer)
+ * @idx: endpoint index (1 => epA, 2 => epB, ..., 24 => epX)
+ * @name: endpoint name (for trace/debug purpose)
+ * @dir_in: 1 if IN endpoint, 0 if OUT endpoint
+ * @addr: usb endpoint number
+ * @config: configuration in which this endpoint is active
+ * @interface: interface in which this endpoint is active
+ * @alternate: altsetting in which this endpoitn is active
+ * @fifo_size: max packet size in the endpoint fifo
+ * @type: endpoint type (bulk, iso, int, ...)
+ * @udccsr_value: save register of UDCCSR0 for suspend/resume
+ * @udccr_value: save register of UDCCR for suspend/resume
+ * @stats: endpoint statistics
+ *
+ * The *PROBLEM* is that pxa's endpoint configuration scheme is both misdesigned
+ * (cares about config/interface/altsetting, thus placing needless limits on
+ * device capability) and full of implementation bugs forcing it to be set up
+ * for use more or less like a pxa255.
+ *
+ * As we define the pxa_ep statically, we must guess all needed pxa_ep for all
+ * gadget which may work with this udc driver.
+ */
+struct pxa_ep {
+        struct pxa_udc          *dev;
+
+        struct list_head        queue;
+        spinlock_t              lock;           /* Protects this structure */
+                                                /* (queues, stats) */
+        unsigned                enabled:1;
+
+        unsigned                idx:5;
+        char                    *name;
+
+        /*
+         * Specific pxa endpoint data, needed for hardware initialization
+         */
+        unsigned                dir_in:1;
+        unsigned                addr:3;
+        unsigned                config:2;
+        unsigned                interface:3;
+        unsigned                alternate:3;
+        unsigned                fifo_size;
+        unsigned                type;
+
+#ifdef CONFIG_PM
+        u32                     udccsr_value;
+        u32                     udccr_value;
+#endif
+        struct stats            stats;
+};
+
+/**
+ * struct pxa27x_request - container of each usb_request structure
+ * @req: usb request
+ * @udc_usb_ep: usb endpoint the request was submitted on
+ * @in_use: sanity check if request already queued on an pxa_ep
+ * @queue: linked list of requests, linked on pxa_ep->queue
+ */
+struct pxa27x_request {
+        struct usb_request                      req;
+        struct udc_usb_ep                       *udc_usb_ep;
+        unsigned                                in_use:1;
+        struct list_head                        queue;
+};
+
+enum ep0_state {
+        WAIT_FOR_SETUP,
+        SETUP_STAGE,
+        IN_DATA_STAGE,
+        OUT_DATA_STAGE,
+        IN_STATUS_STAGE,
+        OUT_STATUS_STAGE,
+        STALL,
+        WAIT_ACK_SET_CONF_INTERF
+};
+
+static char *ep0_state_name[] = {
+        "WAIT_FOR_SETUP", "SETUP_STAGE", "IN_DATA_STAGE", "OUT_DATA_STAGE",
+        "IN_STATUS_STAGE", "OUT_STATUS_STAGE", "STALL",
+        "WAIT_ACK_SET_CONF_INTERF"
+};
+#define EP0_STNAME(udc) ep0_state_name[(udc)->ep0state]
+
+#define EP0_FIFO_SIZE   16U
+#define BULK_FIFO_SIZE  64U
+#define ISO_FIFO_SIZE   256U
+#define INT_FIFO_SIZE   16U
+
+struct udc_stats {
+        unsigned long   irqs_reset;
+        unsigned long   irqs_suspend;
+        unsigned long   irqs_resume;
+        unsigned long   irqs_reconfig;
+};
+
+#define NR_USB_ENDPOINTS (1 + 5)        /* ep0 + ep1in-bulk + .. + ep3in-iso */
+#define NR_PXA_ENDPOINTS (1 + 14)       /* ep0 + epA + epB + .. + epX */
+
+/**
+ * struct pxa_udc - udc structure
+ * @regs: mapped IO space
+ * @irq: udc irq
+ * @clk: udc clock
+ * @usb_gadget: udc gadget structure
+ * @driver: bound gadget (zero, g_ether, g_file_storage, ...)
+ * @dev: device
+ * @mach: machine info, used to activate specific GPIO
+ * @ep0state: control endpoint state machine state
+ * @stats: statistics on udc usage
+ * @udc_usb_ep: array of usb endpoints offered by the gadget
+ * @pxa_ep: array of pxa available endpoints
+ * @config: UDC active configuration
+ * @last_interface: UDC interface of the last SET_INTERFACE host request
+ * @last_alternate: UDC altsetting of the last SET_INTERFACE host request
+ * @udccsr0: save of udccsr0 in case of suspend
+ * @debugfs_root: root entry of debug filesystem
+ * @debugfs_state: debugfs entry for "udcstate"
+ * @debugfs_queues: debugfs entry for "queues"
+ * @debugfs_eps: debugfs entry for "epstate"
+ */
+struct pxa_udc {
+        void __iomem                            *regs;
+        int                                     irq;
+        struct clk                              *clk;
+
+        struct usb_gadget                       gadget;
+        struct usb_gadget_driver                *driver;
+        struct device                           *dev;
+        struct pxa2xx_udc_mach_info             *mach;
+
+        enum ep0_state                          ep0state;
+        struct udc_stats                        stats;
+
+        struct udc_usb_ep                       udc_usb_ep[NR_USB_ENDPOINTS];
+        struct pxa_ep                           pxa_ep[NR_PXA_ENDPOINTS];
+
+        unsigned                                config:2;
+        unsigned                                last_interface:3;
+        unsigned                                last_alternate:3;
+
+#ifdef CONFIG_PM
+        unsigned                                udccsr0;
+#endif
+#ifdef CONFIG_USB_GADGET_DEBUG_FS
+        struct dentry                           *debugfs_root;
+        struct dentry                           *debugfs_state;
+        struct dentry                           *debugfs_queues;
+        struct dentry                           *debugfs_eps;
+#endif
+};
+
+static inline struct pxa_udc *to_gadget_udc(struct usb_gadget *gadget)
+{
+        return container_of(gadget, struct pxa_udc, gadget);
+}
+
+/*
+ * Debugging/message support
+ */
+#define ep_dbg(ep, fmt, arg...) \
+        dev_dbg(ep->dev->dev, "%s:%s: " fmt, EPNAME(ep), __func__, ## arg)
+#define ep_vdbg(ep, fmt, arg...) \
+        dev_vdbg(ep->dev->dev, "%s:%s: " fmt, EPNAME(ep), __func__, ## arg)
+#define ep_err(ep, fmt, arg...) \
+        dev_err(ep->dev->dev, "%s:%s: " fmt, EPNAME(ep), __func__, ## arg)
+#define ep_info(ep, fmt, arg...) \
+        dev_info(ep->dev->dev, "%s:%s: " fmt, EPNAME(ep), __func__, ## arg)
+#define ep_warn(ep, fmt, arg...) \
+        dev_warn(ep->dev->dev, "%s:%s:" fmt, EPNAME(ep), __func__, ## arg)
+
+/*
+ * Cannot include pxa-regs.h, as register names are similar.
+ * So PSSR is redefined here. This should be removed once UDC registers will
+ * be gone from pxa-regs.h.
+ */
+#define PSSR            __REG(0x40F00004)       /* Power Manager Sleep Status */
+#define PSSR_OTGPH      (1 << 6)                /* OTG Peripheral Hold */
+
+#endif /* __LINUX_USB_GADGET_PXA27X_H */
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index 8d158e5640e3..fa019fa73334 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -14,7 +14,6 @@
  * This software is distributed under the terms of the GNU General
  * Public License ("GPL") as published by the Free Software Foundation,
  * either version 2 of that License or (at your option) any later version.
- *
  */
 
 #include <linux/kernel.h>
@@ -33,7 +32,7 @@
 /* Defines */
 
 #define GS_VERSION_STR                  "v2.2"
-#define GS_VERSION_NUM                  0x0202
+#define GS_VERSION_NUM                  0x2200
 
 #define GS_LONG_NAME                    "Gadget Serial"
 #define GS_SHORT_NAME                   "g_serial"
@@ -41,7 +40,11 @@
 #define GS_MAJOR                        127
 #define GS_MINOR_START                  0
 
-#define GS_NUM_PORTS                    16
+/* REVISIT only one port is supported for now;
+ * see gs_{send,recv}_packet() ... no multiplexing,
+ * and no support for multiple ACM devices.
+ */
+#define GS_NUM_PORTS                    1
 
 #define GS_NUM_CONFIGS                  1
 #define GS_NO_CONFIG_ID                 0
@@ -65,6 +68,9 @@
 
 #define GS_DEFAULT_USE_ACM              0
 
+/* 9600-8-N-1 ... matches init_termios.c_cflag and defaults
+ * expected by "usbser.sys" on MS-Windows.
+ */
 #define GS_DEFAULT_DTE_RATE             9600
 #define GS_DEFAULT_DATA_BITS            8
 #define GS_DEFAULT_PARITY               USB_CDC_NO_PARITY
@@ -107,10 +113,6 @@ static int debug = 1;
 #define GS_NOTIFY_MAXPACKET             8
 
 
-/* Structures */
-
-struct gs_dev;
-
 /* circular buffer */
 struct gs_buf {
         unsigned int            buf_size;
@@ -119,12 +121,6 @@ struct gs_buf {
         char                    *buf_put;
 };
 
-/* list of requests */
-struct gs_req_entry {
-        struct list_head        re_entry;
-        struct usb_request      *re_req;
-};
-
 /* the port structure holds info for each port, one for each minor number */
 struct gs_port {
         struct gs_dev           *port_dev;      /* pointer to device struct */
@@ -135,7 +131,10 @@ struct gs_port {
         int                     port_in_use;    /* open/close in progress */
         wait_queue_head_t       port_write_wait;/* waiting to write */
         struct gs_buf           *port_write_buf;
-        struct usb_cdc_line_coding      port_line_coding;
+        struct usb_cdc_line_coding port_line_coding;    /* 8-N-1 etc */
+        u16                     port_handshake_bits;
+#define RS232_RTS       (1 << 1)
+#define RS232_DTE       (1 << 0)
 };
 
 /* the device structure holds info for the USB device */
@@ -161,26 +160,7 @@ struct gs_dev {
 
 /* Functions */
 
-/* module */
-static int __init gs_module_init(void);
-static void __exit gs_module_exit(void);
-
-/* tty driver */
-static int gs_open(struct tty_struct *tty, struct file *file);
-static void gs_close(struct tty_struct *tty, struct file *file);
-static int gs_write(struct tty_struct *tty,
-        const unsigned char *buf, int count);
-static int gs_put_char(struct tty_struct *tty, unsigned char ch);
-static void gs_flush_chars(struct tty_struct *tty);
-static int gs_write_room(struct tty_struct *tty);
-static int gs_chars_in_buffer(struct tty_struct *tty);
-static void gs_throttle(struct tty_struct * tty);
-static void gs_unthrottle(struct tty_struct * tty);
-static void gs_break(struct tty_struct *tty, int break_state);
-static int  gs_ioctl(struct tty_struct *tty, struct file *file,
-        unsigned int cmd, unsigned long arg);
-static void gs_set_termios(struct tty_struct *tty, struct ktermios *old);
-
+/* tty driver internals */
 static int gs_send(struct gs_dev *dev);
 static int gs_send_packet(struct gs_dev *dev, char *packet,
         unsigned int size);
@@ -189,17 +169,7 @@ static int gs_recv_packet(struct gs_dev *dev, char *packet,
 static void gs_read_complete(struct usb_ep *ep, struct usb_request *req);
 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req);
 
-/* gadget driver */
-static int gs_bind(struct usb_gadget *gadget);
-static void gs_unbind(struct usb_gadget *gadget);
-static int gs_setup(struct usb_gadget *gadget,
-        const struct usb_ctrlrequest *ctrl);
-static int gs_setup_standard(struct usb_gadget *gadget,
-        const struct usb_ctrlrequest *ctrl);
-static int gs_setup_class(struct usb_gadget *gadget,
-        const struct usb_ctrlrequest *ctrl);
-static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req);
-static void gs_disconnect(struct usb_gadget *gadget);
+/* gadget driver internals */
 static int gs_set_config(struct gs_dev *dev, unsigned config);
 static void gs_reset_config(struct gs_dev *dev);
 static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
@@ -209,10 +179,6 @@ static struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned int len,
         gfp_t kmalloc_flags);
 static void gs_free_req(struct usb_ep *ep, struct usb_request *req);
 
-static struct gs_req_entry *gs_alloc_req_entry(struct usb_ep *ep, unsigned len,
-        gfp_t kmalloc_flags);
-static void gs_free_req_entry(struct usb_ep *ep, struct gs_req_entry *req);
-
 static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags);
 static void gs_free_ports(struct gs_dev *dev);
 
@@ -227,62 +193,15 @@ static unsigned int gs_buf_put(struct gs_buf *gb, const char *buf,
 static unsigned int gs_buf_get(struct gs_buf *gb, char *buf,
         unsigned int count);
 
-/* external functions */
-extern int net2280_set_fifo_mode(struct usb_gadget *gadget, int mode);
-
 
 /* Globals */
 
 static struct gs_dev *gs_device;
 
-static const char *EP_IN_NAME;
-static const char *EP_OUT_NAME;
-static const char *EP_NOTIFY_NAME;
-
 static struct mutex gs_open_close_lock[GS_NUM_PORTS];
 
-static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE;
-static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE;
-
-static unsigned int write_buf_size = GS_DEFAULT_WRITE_BUF_SIZE;
-
-static unsigned int use_acm = GS_DEFAULT_USE_ACM;
-
-
-/* tty driver struct */
-static const struct tty_operations gs_tty_ops = {
-        .open =                 gs_open,
-        .close =                gs_close,
-        .write =                gs_write,
-        .put_char =             gs_put_char,
-        .flush_chars =          gs_flush_chars,
-        .write_room =           gs_write_room,
-        .ioctl =                gs_ioctl,
-        .set_termios =          gs_set_termios,
-        .throttle =             gs_throttle,
-        .unthrottle =           gs_unthrottle,
-        .break_ctl =            gs_break,
-        .chars_in_buffer =      gs_chars_in_buffer,
-};
-static struct tty_driver *gs_tty_driver;
-
-/* gadget driver struct */
-static struct usb_gadget_driver gs_gadget_driver = {
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        .speed =                USB_SPEED_HIGH,
-#else
-        .speed =                USB_SPEED_FULL,
-#endif /* CONFIG_USB_GADGET_DUALSPEED */
-        .function =             GS_LONG_NAME,
-        .bind =                 gs_bind,
-        .unbind =               gs_unbind,
-        .setup =                gs_setup,
-        .disconnect =           gs_disconnect,
-        .driver = {
-                .name =         GS_SHORT_NAME,
-        },
-};
 
+/*-------------------------------------------------------------------------*/
 
 /* USB descriptors */
 
@@ -299,7 +218,6 @@ static char manufacturer[50];
 static struct usb_string gs_strings[] = {
         { GS_MANUFACTURER_STR_ID, manufacturer },
         { GS_PRODUCT_STR_ID, GS_LONG_NAME },
-        { GS_SERIAL_STR_ID, "0" },
         { GS_BULK_CONFIG_STR_ID, "Gadget Serial Bulk" },
         { GS_ACM_CONFIG_STR_ID, "Gadget Serial CDC ACM" },
         { GS_CONTROL_STR_ID, "Gadget Serial Control" },
@@ -322,7 +240,6 @@ static struct usb_device_descriptor gs_device_desc = {
         .idProduct =            __constant_cpu_to_le16(GS_PRODUCT_ID),
         .iManufacturer =        GS_MANUFACTURER_STR_ID,
         .iProduct =             GS_PRODUCT_STR_ID,
-        .iSerialNumber =        GS_SERIAL_STR_ID,
         .bNumConfigurations =   GS_NUM_CONFIGS,
 };
 
@@ -359,7 +276,7 @@ static const struct usb_interface_descriptor gs_bulk_interface_desc = {
         .bDescriptorType =      USB_DT_INTERFACE,
         .bInterfaceNumber =     GS_BULK_INTERFACE_ID,
         .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_CDC_DATA,
+        .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
         .bInterfaceSubClass =   0,
         .bInterfaceProtocol =   0,
         .iInterface =           GS_DATA_STR_ID,
@@ -406,7 +323,7 @@ static struct usb_cdc_acm_descriptor gs_acm_descriptor = {
         .bLength =              sizeof(gs_acm_descriptor),
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubType =   USB_CDC_ACM_TYPE,
-        .bmCapabilities =       0,
+        .bmCapabilities =       (1 << 1),
 };
 
 static const struct usb_cdc_union_desc gs_union_desc = {
@@ -516,6 +433,8 @@ static const struct usb_descriptor_header *gs_acm_highspeed_function[] = {
 };
 
 
+/*-------------------------------------------------------------------------*/
+
 /* Module */
 MODULE_DESCRIPTION(GS_LONG_NAME);
 MODULE_AUTHOR("Al Borchers");
@@ -526,84 +445,23 @@ module_param(debug, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(debug, "Enable debugging, 0=off, 1=on");
 #endif
 
+static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE;
 module_param(read_q_size, uint, S_IRUGO);
 MODULE_PARM_DESC(read_q_size, "Read request queue size, default=32");
 
+static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE;
 module_param(write_q_size, uint, S_IRUGO);
 MODULE_PARM_DESC(write_q_size, "Write request queue size, default=32");
 
+static unsigned int write_buf_size = GS_DEFAULT_WRITE_BUF_SIZE;
 module_param(write_buf_size, uint, S_IRUGO);
 MODULE_PARM_DESC(write_buf_size, "Write buffer size, default=8192");
 
+static unsigned int use_acm = GS_DEFAULT_USE_ACM;
 module_param(use_acm, uint, S_IRUGO);
 MODULE_PARM_DESC(use_acm, "Use CDC ACM, 0=no, 1=yes, default=no");
 
-module_init(gs_module_init);
-module_exit(gs_module_exit);
-
-/*
-*  gs_module_init
-*
-*  Register as a USB gadget driver and a tty driver.
-*/
-static int __init gs_module_init(void)
-{
-        int i;
-        int retval;
-
-        retval = usb_gadget_register_driver(&gs_gadget_driver);
-        if (retval) {
-                pr_err("gs_module_init: cannot register gadget driver, "
-                        "ret=%d\n", retval);
-                return retval;
-        }
-
-        gs_tty_driver = alloc_tty_driver(GS_NUM_PORTS);
-        if (!gs_tty_driver)
-                return -ENOMEM;
-        gs_tty_driver->owner = THIS_MODULE;
-        gs_tty_driver->driver_name = GS_SHORT_NAME;
-        gs_tty_driver->name = "ttygs";
-        gs_tty_driver->major = GS_MAJOR;
-        gs_tty_driver->minor_start = GS_MINOR_START;
-        gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
-        gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
-        gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
-        gs_tty_driver->init_termios = tty_std_termios;
-        gs_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
-        tty_set_operations(gs_tty_driver, &gs_tty_ops);
-
-        for (i=0; i < GS_NUM_PORTS; i++)
-                mutex_init(&gs_open_close_lock[i]);
-
-        retval = tty_register_driver(gs_tty_driver);
-        if (retval) {
-                usb_gadget_unregister_driver(&gs_gadget_driver);
-                put_tty_driver(gs_tty_driver);
-                pr_err("gs_module_init: cannot register tty driver, "
-                                "ret=%d\n", retval);
-                return retval;
-        }
-
-        pr_info("gs_module_init: %s %s loaded\n",
-                        GS_LONG_NAME, GS_VERSION_STR);
-        return 0;
-}
-
-/*
-* gs_module_exit
-*
-* Unregister as a tty driver and a USB gadget driver.
-*/
-static void __exit gs_module_exit(void)
-{
-        tty_unregister_driver(gs_tty_driver);
-        put_tty_driver(gs_tty_driver);
-        usb_gadget_unregister_driver(&gs_gadget_driver);
-
-        pr_info("gs_module_exit: %s %s unloaded\n",
-                        GS_LONG_NAME, GS_VERSION_STR);
-}
+/*-------------------------------------------------------------------------*/
 
 /* TTY Driver */
 
@@ -748,15 +606,15 @@ exit_unlock_dev:
  * gs_close
  */
 
-#define GS_WRITE_FINISHED_EVENT_SAFELY(p)                       \
-({                                                              \
-        int cond;                                               \
-                                                                \
-        spin_lock_irq(&(p)->port_lock);                         \
-        cond = !(p)->port_dev || !gs_buf_data_avail((p)->port_write_buf); \
-        spin_unlock_irq(&(p)->port_lock);                       \
-        cond;                                                   \
-})
+static int gs_write_finished_event_safely(struct gs_port *p)
+{
+        int cond;
+
+        spin_lock_irq(&(p)->port_lock);
+        cond = !(p)->port_dev || !gs_buf_data_avail((p)->port_write_buf);
+        spin_unlock_irq(&(p)->port_lock);
+        return cond;
+}
 
 static void gs_close(struct tty_struct *tty, struct file *file)
 {
@@ -802,7 +660,7 @@ static void gs_close(struct tty_struct *tty, struct file *file)
         if (gs_buf_data_avail(port->port_write_buf) > 0) {
                 spin_unlock_irq(&port->port_lock);
                 wait_event_interruptible_timeout(port->port_write_wait,
-                                        GS_WRITE_FINISHED_EVENT_SAFELY(port),
+                                        gs_write_finished_event_safely(port),
                                         GS_CLOSE_TIMEOUT * HZ);
                 spin_lock_irq(&port->port_lock);
         }
@@ -1060,6 +918,23 @@ static void gs_set_termios(struct tty_struct *tty, struct ktermios *old)
 {
 }
 
+static const struct tty_operations gs_tty_ops = {
+        .open =                 gs_open,
+        .close =                gs_close,
+        .write =                gs_write,
+        .put_char =             gs_put_char,
+        .flush_chars =          gs_flush_chars,
+        .write_room =           gs_write_room,
+        .ioctl =                gs_ioctl,
+        .set_termios =          gs_set_termios,
+        .throttle =             gs_throttle,
+        .unthrottle =           gs_unthrottle,
+        .break_ctl =            gs_break,
+        .chars_in_buffer =      gs_chars_in_buffer,
+};
+
+/*-------------------------------------------------------------------------*/
+
 /*
 * gs_send
 *
@@ -1075,7 +950,6 @@ static int gs_send(struct gs_dev *dev)
         unsigned long flags;
         struct usb_ep *ep;
         struct usb_request *req;
-        struct gs_req_entry *req_entry;
 
         if (dev == NULL) {
                 pr_err("gs_send: NULL device pointer\n");
@@ -1088,10 +962,8 @@ static int gs_send(struct gs_dev *dev)
 
         while(!list_empty(&dev->dev_req_list)) {
 
-                req_entry = list_entry(dev->dev_req_list.next,
-                        struct gs_req_entry, re_entry);
-
-                req = req_entry->re_req;
+                req = list_entry(dev->dev_req_list.next,
+                                struct usb_request, list);
 
                 len = gs_send_packet(dev, req->buf, ep->maxpacket);
 
@@ -1101,7 +973,7 @@ static int gs_send(struct gs_dev *dev)
                                         *((unsigned char *)req->buf),
                                         *((unsigned char *)req->buf+1),
                                         *((unsigned char *)req->buf+2));
-                        list_del(&req_entry->re_entry);
+                        list_del(&req->list);
                         req->length = len;
                         spin_unlock_irqrestore(&dev->dev_lock, flags);
                         if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
@@ -1284,7 +1156,6 @@ requeue:
 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
 {
         struct gs_dev *dev = ep->driver_data;
-        struct gs_req_entry *gs_req = req->context;
 
         if (dev == NULL) {
                 pr_err("gs_write_complete: NULL device pointer\n");
@@ -1295,13 +1166,8 @@ static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
         case 0:
                 /* normal completion */
 requeue:
-                if (gs_req == NULL) {
-                        pr_err("gs_write_complete: NULL request pointer\n");
-                        return;
-                }
-
                 spin_lock(&dev->dev_lock);
-                list_add(&gs_req->re_entry, &dev->dev_req_list);
+                list_add(&req->list, &dev->dev_req_list);
                 spin_unlock(&dev->dev_lock);
 
                 gs_send(dev);
@@ -1323,9 +1189,39 @@ requeue:
         }
 }
 
+/*-------------------------------------------------------------------------*/
+
 /* Gadget Driver */
 
 /*
+ * gs_unbind
+ *
+ * Called on module unload.  Frees the control request and device
+ * structure.
+ */
+static void /* __init_or_exit */ gs_unbind(struct usb_gadget *gadget)
+{
+        struct gs_dev *dev = get_gadget_data(gadget);
+
+        gs_device = NULL;
+
+        /* read/write requests already freed, only control request remains */
+        if (dev != NULL) {
+                if (dev->dev_ctrl_req != NULL) {
+                        gs_free_req(gadget->ep0, dev->dev_ctrl_req);
+                        dev->dev_ctrl_req = NULL;
+                }
+                gs_reset_config(dev);
+                gs_free_ports(dev);
+                kfree(dev);
+                set_gadget_data(gadget, NULL);
+        }
+
+        pr_info("gs_unbind: %s %s unbound\n", GS_LONG_NAME,
+                GS_VERSION_STR);
+}
+
+/*
  * gs_bind
  *
  * Called on module load.  Allocates and initializes the device
@@ -1357,19 +1253,23 @@ static int __init gs_bind(struct usb_gadget *gadget)
                         __constant_cpu_to_le16(GS_VERSION_NUM|0x0099);
         }
 
+        dev = kzalloc(sizeof(struct gs_dev), GFP_KERNEL);
+        if (dev == NULL)
+                return -ENOMEM;
+
         usb_ep_autoconfig_reset(gadget);
 
         ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc);
         if (!ep)
                 goto autoconf_fail;
-        EP_IN_NAME = ep->name;
-        ep->driver_data = ep;   /* claim the endpoint */
+        dev->dev_in_ep = ep;
+        ep->driver_data = dev;  /* claim the endpoint */
 
         ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc);
         if (!ep)
                 goto autoconf_fail;
-        EP_OUT_NAME = ep->name;
-        ep->driver_data = ep;   /* claim the endpoint */
+        dev->dev_out_ep = ep;
+        ep->driver_data = dev;  /* claim the endpoint */
 
         if (use_acm) {
                 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_notify_desc);
@@ -1379,8 +1279,8 @@ static int __init gs_bind(struct usb_gadget *gadget)
                 }
                 gs_device_desc.idProduct = __constant_cpu_to_le16(
                                                 GS_CDC_PRODUCT_ID),
-                EP_NOTIFY_NAME = ep->name;
-                ep->driver_data = ep;   /* claim the endpoint */
+                dev->dev_notify_ep = ep;
+                ep->driver_data = dev;  /* claim the endpoint */
         }
 
         gs_device_desc.bDeviceClass = use_acm
@@ -1410,9 +1310,7 @@ static int __init gs_bind(struct usb_gadget *gadget)
                 gs_acm_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        gs_device = dev = kzalloc(sizeof(struct gs_dev), GFP_KERNEL);
-        if (dev == NULL)
-                return -ENOMEM;
+        gs_device = dev;
 
         snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
                 init_utsname()->sysname, init_utsname()->release,
@@ -1436,8 +1334,6 @@ static int __init gs_bind(struct usb_gadget *gadget)
                 gs_unbind(gadget);
                 return -ENOMEM;
         }
-        dev->dev_ctrl_req->complete = gs_setup_complete;
-
         gadget->ep0->driver_data = dev;
 
         pr_info("gs_bind: %s %s bound\n",
@@ -1446,97 +1342,11 @@ static int __init gs_bind(struct usb_gadget *gadget)
         return 0;
 
 autoconf_fail:
+        kfree(dev);
         pr_err("gs_bind: cannot autoconfigure on %s\n", gadget->name);
         return -ENODEV;
 }
 
-/*
- * gs_unbind
- *
- * Called on module unload.  Frees the control request and device
- * structure.
- */
-static void /* __init_or_exit */ gs_unbind(struct usb_gadget *gadget)
-{
-        struct gs_dev *dev = get_gadget_data(gadget);
-
-        gs_device = NULL;
-
-        /* read/write requests already freed, only control request remains */
-        if (dev != NULL) {
-                if (dev->dev_ctrl_req != NULL) {
-                        gs_free_req(gadget->ep0, dev->dev_ctrl_req);
-                        dev->dev_ctrl_req = NULL;
-                }
-                gs_free_ports(dev);
-                if (dev->dev_notify_ep)
-                        usb_ep_disable(dev->dev_notify_ep);
-                if (dev->dev_in_ep)
-                        usb_ep_disable(dev->dev_in_ep);
-                if (dev->dev_out_ep)
-                        usb_ep_disable(dev->dev_out_ep);
-                kfree(dev);
-                set_gadget_data(gadget, NULL);
-        }
-
-        pr_info("gs_unbind: %s %s unbound\n", GS_LONG_NAME,
-                GS_VERSION_STR);
-}
-
-/*
- * gs_setup
- *
- * Implements all the control endpoint functionality that's not
- * handled in hardware or the hardware driver.
- *
- * Returns the size of the data sent to the host, or a negative
- * error number.
- */
-static int gs_setup(struct usb_gadget *gadget,
-        const struct usb_ctrlrequest *ctrl)
-{
-        int ret = -EOPNOTSUPP;
-        struct gs_dev *dev = get_gadget_data(gadget);
-        struct usb_request *req = dev->dev_ctrl_req;
-        u16 wIndex = le16_to_cpu(ctrl->wIndex);
-        u16 wValue = le16_to_cpu(ctrl->wValue);
-        u16 wLength = le16_to_cpu(ctrl->wLength);
-
-        switch (ctrl->bRequestType & USB_TYPE_MASK) {
-        case USB_TYPE_STANDARD:
-                ret = gs_setup_standard(gadget,ctrl);
-                break;
-
-        case USB_TYPE_CLASS:
-                ret = gs_setup_class(gadget,ctrl);
-                break;
-
-        default:
-                pr_err("gs_setup: unknown request, type=%02x, request=%02x, "
-                        "value=%04x, index=%04x, length=%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        wValue, wIndex, wLength);
-                break;
-        }
-
-        /* respond with data transfer before status phase? */
-        if (ret >= 0) {
-                req->length = ret;
-                req->zero = ret < wLength
-                                && (ret % gadget->ep0->maxpacket) == 0;
-                ret = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
-                if (ret < 0) {
-                        pr_err("gs_setup: cannot queue response, ret=%d\n",
-                                ret);
-                        req->status = 0;
-                        gs_setup_complete(gadget->ep0, req);
-                }
-        }
-
-        /* device either stalls (ret < 0) or reports success */
-        return ret;
-}
-
 static int gs_setup_standard(struct usb_gadget *gadget,
         const struct usb_ctrlrequest *ctrl)
 {
@@ -1666,6 +1476,42 @@ set_interface_done:
         return ret;
 }
 
+static void gs_setup_complete_set_line_coding(struct usb_ep *ep,
+                struct usb_request *req)
+{
+        struct gs_dev *dev = ep->driver_data;
+        struct gs_port *port = dev->dev_port[0]; /* ACM only has one port */
+
+        switch (req->status) {
+        case 0:
+                /* normal completion */
+                if (req->actual != sizeof(port->port_line_coding))
+                        usb_ep_set_halt(ep);
+                else if (port) {
+                        struct usb_cdc_line_coding      *value = req->buf;
+
+                        /* REVISIT:  we currently just remember this data.
+                         * If we change that, (a) validate it first, then
+                         * (b) update whatever hardware needs updating.
+                         */
+                        spin_lock(&port->port_lock);
+                        port->port_line_coding = *value;
+                        spin_unlock(&port->port_lock);
+                }
+                break;
+
+        case -ESHUTDOWN:
+                /* disconnect */
+                gs_free_req(ep, req);
+                break;
+
+        default:
+                /* unexpected */
+                break;
+        }
+        return;
+}
+
 static int gs_setup_class(struct usb_gadget *gadget,
         const struct usb_ctrlrequest *ctrl)
 {
@@ -1679,18 +1525,14 @@ static int gs_setup_class(struct usb_gadget *gadget,
 
         switch (ctrl->bRequest) {
         case USB_CDC_REQ_SET_LINE_CODING:
-                /* FIXME Submit req to read the data; have its completion
-                 * handler copy that data to port->port_line_coding (iff
-                 * it's valid) and maybe pass it on.  Until then, fail.
-                 */
-                pr_warning("gs_setup: set_line_coding "
-                                "unuspported\n");
+                if (wLength != sizeof(struct usb_cdc_line_coding))
+                        break;
+                ret = wLength;
+                req->complete = gs_setup_complete_set_line_coding;
                 break;
 
         case USB_CDC_REQ_GET_LINE_CODING:
-                port = dev->dev_port[0];        /* ACM only has one port */
-                ret = min(wLength,
-                        (u16)sizeof(struct usb_cdc_line_coding));
+                ret = min_t(int, wLength, sizeof(struct usb_cdc_line_coding));
                 if (port) {
                         spin_lock(&port->port_lock);
                         memcpy(req->buf, &port->port_line_coding, ret);
@@ -1699,15 +1541,27 @@ static int gs_setup_class(struct usb_gadget *gadget,
                 break;
 
         case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
-                /* FIXME Submit req to read the data; have its completion
-                 * handler use that to set the state (iff it's valid) and
-                 * maybe pass it on.  Until then, fail.
-                 */
-                pr_warning("gs_setup: set_control_line_state "
-                                "unuspported\n");
+                if (wLength != 0)
+                        break;
+                ret = 0;
+                if (port) {
+                        /* REVISIT:  we currently just remember this data.
+                         * If we change that, update whatever hardware needs
+                         * updating.
+                         */
+                        spin_lock(&port->port_lock);
+                        port->port_handshake_bits = wValue;
+                        spin_unlock(&port->port_lock);
+                }
                 break;
 
         default:
+                /* NOTE:  strictly speaking, we should accept AT-commands
+                 * using SEND_ENCPSULATED_COMMAND/GET_ENCAPSULATED_RESPONSE.
+                 * But our call management descriptor says we don't handle
+                 * call management, so we should be able to get by without
+                 * handling those "required" commands (except by stalling).
+                 */
                 pr_err("gs_setup: unknown class request, "
                                 "type=%02x, request=%02x, value=%04x, "
                                 "index=%04x, length=%d\n",
@@ -1732,6 +1586,62 @@ static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req)
 }
 
 /*
+ * gs_setup
+ *
+ * Implements all the control endpoint functionality that's not
+ * handled in hardware or the hardware driver.
+ *
+ * Returns the size of the data sent to the host, or a negative
+ * error number.
+ */
+static int gs_setup(struct usb_gadget *gadget,
+        const struct usb_ctrlrequest *ctrl)
+{
+        int             ret = -EOPNOTSUPP;
+        struct gs_dev   *dev = get_gadget_data(gadget);
+        struct usb_request *req = dev->dev_ctrl_req;
+        u16             wIndex = le16_to_cpu(ctrl->wIndex);
+        u16             wValue = le16_to_cpu(ctrl->wValue);
+        u16             wLength = le16_to_cpu(ctrl->wLength);
+
+        req->complete = gs_setup_complete;
+
+        switch (ctrl->bRequestType & USB_TYPE_MASK) {
+        case USB_TYPE_STANDARD:
+                ret = gs_setup_standard(gadget, ctrl);
+                break;
+
+        case USB_TYPE_CLASS:
+                ret = gs_setup_class(gadget, ctrl);
+                break;
+
+        default:
+                pr_err("gs_setup: unknown request, type=%02x, request=%02x, "
+                        "value=%04x, index=%04x, length=%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        wValue, wIndex, wLength);
+                break;
+        }
+
+        /* respond with data transfer before status phase? */
+        if (ret >= 0) {
+                req->length = ret;
+                req->zero = ret < wLength
+                                && (ret % gadget->ep0->maxpacket) == 0;
+                ret = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
+                if (ret < 0) {
+                        pr_err("gs_setup: cannot queue response, ret=%d\n",
+                                ret);
+                        req->status = 0;
+                        gs_setup_complete(gadget->ep0, req);
+                }
+        }
+
+        /* device either stalls (ret < 0) or reports success */
+        return ret;
+}
+
+/*
  * gs_disconnect
  *
  * Called when the device is disconnected.  Frees the closed
@@ -1760,6 +1670,23 @@ static void gs_disconnect(struct usb_gadget *gadget)
         pr_info("gs_disconnect: %s disconnected\n", GS_LONG_NAME);
 }
 
+static struct usb_gadget_driver gs_gadget_driver = {
+#ifdef CONFIG_USB_GADGET_DUALSPEED
+        .speed =                USB_SPEED_HIGH,
+#else
+        .speed =                USB_SPEED_FULL,
+#endif /* CONFIG_USB_GADGET_DUALSPEED */
+        .function =             GS_LONG_NAME,
+        .bind =                 gs_bind,
+        .unbind =               gs_unbind,
+        .setup =                gs_setup,
+        .disconnect =           gs_disconnect,
+        .driver = {
+                .name =         GS_SHORT_NAME,
+                .owner =        THIS_MODULE,
+        },
+};
+
 /*
  * gs_set_config
  *
@@ -1775,9 +1702,8 @@ static int gs_set_config(struct gs_dev *dev, unsigned config)
         int ret = 0;
         struct usb_gadget *gadget = dev->dev_gadget;
         struct usb_ep *ep;
-        struct usb_endpoint_descriptor *ep_desc;
+        struct usb_endpoint_descriptor *out, *in, *notify;
         struct usb_request *req;
-        struct gs_req_entry *req_entry;
 
         if (dev == NULL) {
                 pr_err("gs_set_config: NULL device pointer\n");
@@ -1795,86 +1721,62 @@ static int gs_set_config(struct gs_dev *dev, unsigned config)
         case GS_BULK_CONFIG_ID:
                 if (use_acm)
                         return -EINVAL;
-                /* device specific optimizations */
-                if (gadget_is_net2280(gadget))
-                        net2280_set_fifo_mode(gadget, 1);
                 break;
         case GS_ACM_CONFIG_ID:
                 if (!use_acm)
                         return -EINVAL;
-                /* device specific optimizations */
-                if (gadget_is_net2280(gadget))
-                        net2280_set_fifo_mode(gadget, 1);
                 break;
         default:
                 return -EINVAL;
         }
 
-        dev->dev_config = config;
-
-        gadget_for_each_ep(ep, gadget) {
-
-                if (EP_NOTIFY_NAME
-                && strcmp(ep->name, EP_NOTIFY_NAME) == 0) {
-                        ep_desc = choose_ep_desc(gadget,
+        in = choose_ep_desc(gadget,
+                        &gs_highspeed_in_desc,
+                        &gs_fullspeed_in_desc);
+        out = choose_ep_desc(gadget,
+                        &gs_highspeed_out_desc,
+                        &gs_fullspeed_out_desc);
+        notify = dev->dev_notify_ep
+                ? choose_ep_desc(gadget,
                                 &gs_highspeed_notify_desc,
-                                &gs_fullspeed_notify_desc);
-                        ret = usb_ep_enable(ep,ep_desc);
-                        if (ret == 0) {
-                                ep->driver_data = dev;
-                                dev->dev_notify_ep = ep;
-                                dev->dev_notify_ep_desc = ep_desc;
-                        } else {
-                                pr_err("gs_set_config: cannot enable NOTIFY "
-                                        "endpoint %s, ret=%d\n",
-                                        ep->name, ret);
-                                goto exit_reset_config;
-                        }
-                }
+                                &gs_fullspeed_notify_desc)
+                : NULL;
 
-                else if (strcmp(ep->name, EP_IN_NAME) == 0) {
-                        ep_desc = choose_ep_desc(gadget,
-                                &gs_highspeed_in_desc,
-                                &gs_fullspeed_in_desc);
-                        ret = usb_ep_enable(ep,ep_desc);
-                        if (ret == 0) {
-                                ep->driver_data = dev;
-                                dev->dev_in_ep = ep;
-                                dev->dev_in_ep_desc = ep_desc;
-                        } else {
-                                pr_err("gs_set_config: cannot enable IN "
-                                        "endpoint %s, ret=%d\n",
-                                        ep->name, ret);
-                                goto exit_reset_config;
-                        }
-                }
-
-                else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
-                        ep_desc = choose_ep_desc(gadget,
-                                &gs_highspeed_out_desc,
-                                &gs_fullspeed_out_desc);
-                        ret = usb_ep_enable(ep,ep_desc);
-                        if (ret == 0) {
-                                ep->driver_data = dev;
-                                dev->dev_out_ep = ep;
-                                dev->dev_out_ep_desc = ep_desc;
-                        } else {
-                                pr_err("gs_set_config: cannot enable OUT "
-                                        "endpoint %s, ret=%d\n",
-                                        ep->name, ret);
-                                goto exit_reset_config;
-                        }
-                }
+        ret = usb_ep_enable(dev->dev_in_ep, in);
+        if (ret == 0) {
+                dev->dev_in_ep_desc = in;
+        } else {
+                pr_debug("%s: cannot enable %s %s, ret=%d\n",
+                        __func__, "IN", dev->dev_in_ep->name, ret);
+                return ret;
+        }
 
+        ret = usb_ep_enable(dev->dev_out_ep, out);
+        if (ret == 0) {
+                dev->dev_out_ep_desc = out;
+        } else {
+                pr_debug("%s: cannot enable %s %s, ret=%d\n",
+                        __func__, "OUT", dev->dev_out_ep->name, ret);
+fail0:
+                usb_ep_disable(dev->dev_in_ep);
+                return ret;
         }
 
-        if (dev->dev_in_ep == NULL || dev->dev_out_ep == NULL
-        || (config != GS_BULK_CONFIG_ID && dev->dev_notify_ep == NULL)) {
-                pr_err("gs_set_config: cannot find endpoints\n");
-                ret = -ENODEV;
-                goto exit_reset_config;
+        if (notify) {
+                ret = usb_ep_enable(dev->dev_notify_ep, notify);
+                if (ret == 0) {
+                        dev->dev_notify_ep_desc = notify;
+                } else {
+                        pr_debug("%s: cannot enable %s %s, ret=%d\n",
+                                __func__, "NOTIFY",
+                                dev->dev_notify_ep->name, ret);
+                        usb_ep_disable(dev->dev_out_ep);
+                        goto fail0;
+                }
         }
 
+        dev->dev_config = config;
+
         /* allocate and queue read requests */
         ep = dev->dev_out_ep;
         for (i=0; i<read_q_size && ret == 0; i++) {
@@ -1895,9 +1797,10 @@ static int gs_set_config(struct gs_dev *dev, unsigned config)
         /* allocate write requests, and put on free list */
         ep = dev->dev_in_ep;
         for (i=0; i<write_q_size; i++) {
-                if ((req_entry=gs_alloc_req_entry(ep, ep->maxpacket, GFP_ATOMIC))) {
-                        req_entry->re_req->complete = gs_write_complete;
-                        list_add(&req_entry->re_entry, &dev->dev_req_list);
+                req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
+                if (req) {
+                        req->complete = gs_write_complete;
+                        list_add(&req->list, &dev->dev_req_list);
                 } else {
                         pr_err("gs_set_config: cannot allocate "
                                         "write requests\n");
@@ -1906,6 +1809,11 @@ static int gs_set_config(struct gs_dev *dev, unsigned config)
                 }
         }
 
+        /* REVISIT the ACM mode should be able to actually *issue* some
+         * notifications, for at least serial state change events if
+         * not also for network connection; say so in bmCapabilities.
+         */
+
         pr_info("gs_set_config: %s configured, %s speed %s config\n",
                 GS_LONG_NAME,
                 gadget->speed == USB_SPEED_HIGH ? "high" : "full",
@@ -1930,7 +1838,7 @@ exit_reset_config:
  */
 static void gs_reset_config(struct gs_dev *dev)
 {
-        struct gs_req_entry *req_entry;
+        struct usb_request *req;
 
         if (dev == NULL) {
                 pr_err("gs_reset_config: NULL device pointer\n");
@@ -1944,26 +1852,18 @@ static void gs_reset_config(struct gs_dev *dev)
 
         /* free write requests on the free list */
         while(!list_empty(&dev->dev_req_list)) {
-                req_entry = list_entry(dev->dev_req_list.next,
-                        struct gs_req_entry, re_entry);
-                list_del(&req_entry->re_entry);
-                gs_free_req_entry(dev->dev_in_ep, req_entry);
+                req = list_entry(dev->dev_req_list.next,
+                                struct usb_request, list);
+                list_del(&req->list);
+                gs_free_req(dev->dev_in_ep, req);
         }
 
         /* disable endpoints, forcing completion of pending i/o; */
         /* completion handlers free their requests in this case */
-        if (dev->dev_notify_ep) {
+        if (dev->dev_notify_ep)
                 usb_ep_disable(dev->dev_notify_ep);
-                dev->dev_notify_ep = NULL;
-        }
-        if (dev->dev_in_ep) {
-                usb_ep_disable(dev->dev_in_ep);
-                dev->dev_in_ep = NULL;
-        }
-        if (dev->dev_out_ep) {
-                usb_ep_disable(dev->dev_out_ep);
-                dev->dev_out_ep = NULL;
-        }
+        usb_ep_disable(dev->dev_in_ep);
+        usb_ep_disable(dev->dev_out_ep);
 }
 
 /*
@@ -2057,46 +1957,6 @@ static void gs_free_req(struct usb_ep *ep, struct usb_request *req)
 }
 
 /*
- * gs_alloc_req_entry
- *
- * Allocates a request and its buffer, using the given
- * endpoint, buffer len, and kmalloc flags.
- */
-static struct gs_req_entry *
-gs_alloc_req_entry(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
-{
-        struct gs_req_entry     *req;
-
-        req = kmalloc(sizeof(struct gs_req_entry), kmalloc_flags);
-        if (req == NULL)
-                return NULL;
-
-        req->re_req = gs_alloc_req(ep, len, kmalloc_flags);
-        if (req->re_req == NULL) {
-                kfree(req);
-                return NULL;
-        }
-
-        req->re_req->context = req;
-
-        return req;
-}
-
-/*
- * gs_free_req_entry
- *
- * Frees a request and its buffer.
- */
-static void gs_free_req_entry(struct usb_ep *ep, struct gs_req_entry *req)
-{
-        if (ep != NULL && req != NULL) {
-                if (req->re_req != NULL)
-                        gs_free_req(ep, req->re_req);
-                kfree(req);
-        }
-}
-
-/*
  * gs_alloc_ports
  *
  * Allocate all ports and set the gs_dev struct to point to them.
@@ -2177,6 +2037,8 @@ static void gs_free_ports(struct gs_dev *dev)
         }
 }
 
+/*-------------------------------------------------------------------------*/
+
 /* Circular Buffer */
 
 /*
@@ -2337,3 +2199,77 @@ gs_buf_get(struct gs_buf *gb, char *buf, unsigned int count)
 
         return count;
 }
+
+/*-------------------------------------------------------------------------*/
+
+static struct tty_driver *gs_tty_driver;
+
+/*
+ *  gs_module_init
+ *
+ *  Register as a USB gadget driver and a tty driver.
+ */
+static int __init gs_module_init(void)
+{
+        int i;
+        int retval;
+
+        retval = usb_gadget_register_driver(&gs_gadget_driver);
+        if (retval) {
+                pr_err("gs_module_init: cannot register gadget driver, "
+                        "ret=%d\n", retval);
+                return retval;
+        }
+
+        gs_tty_driver = alloc_tty_driver(GS_NUM_PORTS);
+        if (!gs_tty_driver)
+                return -ENOMEM;
+        gs_tty_driver->owner = THIS_MODULE;
+        gs_tty_driver->driver_name = GS_SHORT_NAME;
+        gs_tty_driver->name = "ttygs";
+        gs_tty_driver->major = GS_MAJOR;
+        gs_tty_driver->minor_start = GS_MINOR_START;
+        gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
+        gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
+        gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+        gs_tty_driver->init_termios = tty_std_termios;
+        /* must match GS_DEFAULT_DTE_RATE and friends */
+        gs_tty_driver->init_termios.c_cflag =
+                B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        gs_tty_driver->init_termios.c_ispeed = GS_DEFAULT_DTE_RATE;
+        gs_tty_driver->init_termios.c_ospeed = GS_DEFAULT_DTE_RATE;
+        tty_set_operations(gs_tty_driver, &gs_tty_ops);
+
+        for (i = 0; i < GS_NUM_PORTS; i++)
+                mutex_init(&gs_open_close_lock[i]);
+
+        retval = tty_register_driver(gs_tty_driver);
+        if (retval) {
+                usb_gadget_unregister_driver(&gs_gadget_driver);
+                put_tty_driver(gs_tty_driver);
+                pr_err("gs_module_init: cannot register tty driver, "
+                                "ret=%d\n", retval);
+                return retval;
+        }
+
+        pr_info("gs_module_init: %s %s loaded\n",
+                        GS_LONG_NAME, GS_VERSION_STR);
+        return 0;
+}
+module_init(gs_module_init);
+
+/*
+ * gs_module_exit
+ *
+ * Unregister as a tty driver and a USB gadget driver.
+ */
+static void __exit gs_module_exit(void)
+{
+        tty_unregister_driver(gs_tty_driver);
+        put_tty_driver(gs_tty_driver);
+        usb_gadget_unregister_driver(&gs_gadget_driver);
+
+        pr_info("gs_module_exit: %s %s unloaded\n",
+                        GS_LONG_NAME, GS_VERSION_STR);
+}
+module_exit(gs_module_exit);
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index d3d4f4048e6c..fce4924dbbe8 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -23,9 +23,7 @@
 /*
  * Gadget Zero only needs two bulk endpoints, and is an example of how you
  * can write a hardware-agnostic gadget driver running inside a USB device.
- *
- * Hardware details are visible (see CONFIG_USB_ZERO_* below) but don't
- * affect most of the driver.
+ * Some hardware details are visible, but don't affect most of the driver.
  *
  * Use it with the Linux host/master side "usbtest" driver to get a basic
  * functional test of your device-side usb stack, or with "usb-skeleton".
@@ -37,6 +35,7 @@
  *   buflen=N           default N=4096, buffer size used
  *   qlen=N             default N=32, how many buffers in the loopback queue
  *   loopdefault        default false, list loopback config first
+ *   autoresume=N       default N=0, seconds before triggering remote wakeup
  *
  * Many drivers will only have one configuration, letting them be much
  * simpler if they also don't support high speed operation (like this
@@ -62,13 +61,13 @@
 
 /*-------------------------------------------------------------------------*/
 
-#define DRIVER_VERSION          "Lughnasadh, 2007"
+#define DRIVER_VERSION          "Earth Day 2008"
 
-static const char shortname [] = "zero";
-static const char longname [] = "Gadget Zero";
+static const char shortname[] = "zero";
+static const char longname[] = "Gadget Zero";
 
-static const char source_sink [] = "source and sink data";
-static const char loopback [] = "loop input to output";
+static const char source_sink[] = "source and sink data";
+static const char loopback[] = "loop input to output";
 
 /*-------------------------------------------------------------------------*/
 
@@ -120,16 +119,16 @@ static unsigned buflen = 4096;
 static unsigned qlen = 32;
 static unsigned pattern = 0;
 
-module_param (buflen, uint, S_IRUGO);
-module_param (qlen, uint, S_IRUGO);
-module_param (pattern, uint, S_IRUGO|S_IWUSR);
+module_param(buflen, uint, S_IRUGO);
+module_param(qlen, uint, S_IRUGO);
+module_param(pattern, uint, S_IRUGO|S_IWUSR);
 
 /*
  * if it's nonzero, autoresume says how many seconds to wait
  * before trying to wake up the host after suspend.
  */
 static unsigned autoresume = 0;
-module_param (autoresume, uint, 0);
+module_param(autoresume, uint, 0);
 
 /*
  * Normally the "loopback" configuration is second (index 1) so
@@ -138,8 +137,7 @@ module_param (autoresume, uint, 0);
  * Or controllers (like superh) that only support one config.
  */
 static int loopdefault = 0;
-
-module_param (loopdefault, bool, S_IRUGO|S_IWUSR);
+module_param(loopdefault, bool, S_IRUGO|S_IWUSR);
 
 /*-------------------------------------------------------------------------*/
 
@@ -176,24 +174,22 @@ module_param (loopdefault, bool, S_IRUGO|S_IWUSR);
 #define CONFIG_SOURCE_SINK      3
 #define CONFIG_LOOPBACK         2
 
-static struct usb_device_descriptor
-device_desc = {
+static struct usb_device_descriptor device_desc = {
         .bLength =              sizeof device_desc,
         .bDescriptorType =      USB_DT_DEVICE,
 
-        .bcdUSB =               __constant_cpu_to_le16 (0x0200),
+        .bcdUSB =               __constant_cpu_to_le16(0x0200),
         .bDeviceClass =         USB_CLASS_VENDOR_SPEC,
 
-        .idVendor =             __constant_cpu_to_le16 (DRIVER_VENDOR_NUM),
-        .idProduct =            __constant_cpu_to_le16 (DRIVER_PRODUCT_NUM),
+        .idVendor =             __constant_cpu_to_le16(DRIVER_VENDOR_NUM),
+        .idProduct =            __constant_cpu_to_le16(DRIVER_PRODUCT_NUM),
         .iManufacturer =        STRING_MANUFACTURER,
         .iProduct =             STRING_PRODUCT,
         .iSerialNumber =        STRING_SERIAL,
         .bNumConfigurations =   2,
 };
 
-static struct usb_config_descriptor
-source_sink_config = {
+static struct usb_config_descriptor source_sink_config = {
         .bLength =              sizeof source_sink_config,
         .bDescriptorType =      USB_DT_CONFIG,
 
@@ -205,8 +201,7 @@ source_sink_config = {
         .bMaxPower =            1,      /* self-powered */
 };
 
-static struct usb_config_descriptor
-loopback_config = {
+static struct usb_config_descriptor loopback_config = {
         .bLength =              sizeof loopback_config,
         .bDescriptorType =      USB_DT_CONFIG,
 
@@ -218,8 +213,7 @@ loopback_config = {
         .bMaxPower =            1,      /* self-powered */
 };
 
-static struct usb_otg_descriptor
-otg_descriptor = {
+static struct usb_otg_descriptor otg_descriptor = {
         .bLength =              sizeof otg_descriptor,
         .bDescriptorType =      USB_DT_OTG,
 
@@ -228,8 +222,7 @@ otg_descriptor = {
 
 /* one interface in each configuration */
 
-static const struct usb_interface_descriptor
-source_sink_intf = {
+static const struct usb_interface_descriptor source_sink_intf = {
         .bLength =              sizeof source_sink_intf,
         .bDescriptorType =      USB_DT_INTERFACE,
 
@@ -238,8 +231,7 @@ source_sink_intf = {
         .iInterface =           STRING_SOURCE_SINK,
 };
 
-static const struct usb_interface_descriptor
-loopback_intf = {
+static const struct usb_interface_descriptor loopback_intf = {
         .bLength =              sizeof loopback_intf,
         .bDescriptorType =      USB_DT_INTERFACE,
 
@@ -250,8 +242,7 @@ loopback_intf = {
 
 /* two full speed bulk endpoints; their use is config-dependent */
 
-static struct usb_endpoint_descriptor
-fs_source_desc = {
+static struct usb_endpoint_descriptor fs_source_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -259,8 +250,7 @@ fs_source_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 };
 
-static struct usb_endpoint_descriptor
-fs_sink_desc = {
+static struct usb_endpoint_descriptor fs_sink_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -268,7 +258,7 @@ fs_sink_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 };
 
-static const struct usb_descriptor_header *fs_source_sink_function [] = {
+static const struct usb_descriptor_header *fs_source_sink_function[] = {
         (struct usb_descriptor_header *) &otg_descriptor,
         (struct usb_descriptor_header *) &source_sink_intf,
         (struct usb_descriptor_header *) &fs_sink_desc,
@@ -276,7 +266,7 @@ static const struct usb_descriptor_header *fs_source_sink_function [] = {
         NULL,
 };
 
-static const struct usb_descriptor_header *fs_loopback_function [] = {
+static const struct usb_descriptor_header *fs_loopback_function[] = {
         (struct usb_descriptor_header *) &otg_descriptor,
         (struct usb_descriptor_header *) &loopback_intf,
         (struct usb_descriptor_header *) &fs_sink_desc,
@@ -293,36 +283,33 @@ static const struct usb_descriptor_header *fs_loopback_function [] = {
  * for the config descriptor.
  */
 
-static struct usb_endpoint_descriptor
-hs_source_desc = {
+static struct usb_endpoint_descriptor hs_source_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16 (512),
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
 };
 
-static struct usb_endpoint_descriptor
-hs_sink_desc = {
+static struct usb_endpoint_descriptor hs_sink_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16 (512),
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
 };
 
-static struct usb_qualifier_descriptor
-dev_qualifier = {
+static struct usb_qualifier_descriptor dev_qualifier = {
         .bLength =              sizeof dev_qualifier,
         .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
 
-        .bcdUSB =               __constant_cpu_to_le16 (0x0200),
+        .bcdUSB =               __constant_cpu_to_le16(0x0200),
         .bDeviceClass =         USB_CLASS_VENDOR_SPEC,
 
         .bNumConfigurations =   2,
 };
 
-static const struct usb_descriptor_header *hs_source_sink_function [] = {
+static const struct usb_descriptor_header *hs_source_sink_function[] = {
         (struct usb_descriptor_header *) &otg_descriptor,
         (struct usb_descriptor_header *) &source_sink_intf,
         (struct usb_descriptor_header *) &hs_source_desc,
@@ -330,7 +317,7 @@ static const struct usb_descriptor_header *hs_source_sink_function [] = {
         NULL,
 };
 
-static const struct usb_descriptor_header *hs_loopback_function [] = {
+static const struct usb_descriptor_header *hs_loopback_function[] = {
         (struct usb_descriptor_header *) &otg_descriptor,
         (struct usb_descriptor_header *) &loopback_intf,
         (struct usb_descriptor_header *) &hs_source_desc,
@@ -355,7 +342,7 @@ static char serial[] = "0123456789.0123456789.0123456789";
 
 
 /* static strings, in UTF-8 */
-static struct usb_string                strings [] = {
+static struct usb_string strings[] = {
         { STRING_MANUFACTURER, manufacturer, },
         { STRING_PRODUCT, longname, },
         { STRING_SERIAL, serial, },
@@ -364,7 +351,7 @@ static struct usb_string		strings [] = {
         {  }                    /* end of list */
 };
 
-static struct usb_gadget_strings        stringtab = {
+static struct usb_gadget_strings stringtab = {
         .language       = 0x0409,       /* en-us */
         .strings        = strings,
 };
@@ -387,8 +374,7 @@ static struct usb_gadget_strings	stringtab = {
  * high bandwidth modes at high speed.  (Maybe work like Intel's test
  * device?)
  */
-static int
-config_buf (struct usb_gadget *gadget,
+static int config_buf(struct usb_gadget *gadget,
                 u8 *buf, u8 type, unsigned index)
 {
         int                             is_source_sink;
@@ -419,7 +405,7 @@ config_buf (struct usb_gadget *gadget,
         if (!gadget_is_otg(gadget))
                 function++;
 
-        len = usb_gadget_config_buf (is_source_sink
+        len = usb_gadget_config_buf(is_source_sink
                                         ? &source_sink_config
                                         : &loopback_config,
                         buf, USB_BUFSIZ, function);
@@ -431,27 +417,26 @@ config_buf (struct usb_gadget *gadget,
 
 /*-------------------------------------------------------------------------*/
 
-static struct usb_request *
-alloc_ep_req (struct usb_ep *ep, unsigned length)
+static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
 {
         struct usb_request      *req;
 
-        req = usb_ep_alloc_request (ep, GFP_ATOMIC);
+        req = usb_ep_alloc_request(ep, GFP_ATOMIC);
         if (req) {
                 req->length = length;
                 req->buf = kmalloc(length, GFP_ATOMIC);
                 if (!req->buf) {
-                        usb_ep_free_request (ep, req);
+                        usb_ep_free_request(ep, req);
                         req = NULL;
                 }
         }
         return req;
 }
 
-static void free_ep_req (struct usb_ep *ep, struct usb_request *req)
+static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
 {
         kfree(req->buf);
-        usb_ep_free_request (ep, req);
+        usb_ep_free_request(ep, req);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -472,7 +457,7 @@ static void free_ep_req (struct usb_ep *ep, struct usb_request *req)
 /* optionally require specific source/sink data patterns  */
 
 static int
-check_read_data (
+check_read_data(
         struct zero_dev         *dev,
         struct usb_ep           *ep,
         struct usb_request      *req
@@ -498,8 +483,8 @@ check_read_data (
                                 continue;
                         break;
                 }
-                ERROR (dev, "bad OUT byte, buf [%d] = %d\n", i, *buf);
-                usb_ep_set_halt (ep);
+                ERROR(dev, "bad OUT byte, buf[%d] = %d\n", i, *buf);
+                usb_ep_set_halt(ep);
                 return -EINVAL;
         }
         return 0;
@@ -512,7 +497,7 @@ static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
 
         switch (pattern) {
         case 0:
-                memset (req->buf, 0, req->length);
+                memset(req->buf, 0, req->length);
                 break;
         case 1:
                 for  (i = 0; i < req->length; i++)
@@ -525,7 +510,7 @@ static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
  * irq delay between end of one request and start of the next.
  * that prevents using hardware dma queues.
  */
-static void source_sink_complete (struct usb_ep *ep, struct usb_request *req)
+static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
 {
         struct zero_dev *dev = ep->driver_data;
         int             status = req->status;
@@ -534,8 +519,8 @@ static void source_sink_complete (struct usb_ep *ep, struct usb_request *req)
 
         case 0:                         /* normal completion? */
                 if (ep == dev->out_ep) {
-                        check_read_data (dev, ep, req);
-                        memset (req->buf, 0x55, req->length);
+                        check_read_data(dev, ep, req);
+                        memset(req->buf, 0x55, req->length);
                 } else
                         reinit_write_data(ep, req);
                 break;
@@ -544,11 +529,11 @@ static void source_sink_complete (struct usb_ep *ep, struct usb_request *req)
         case -ECONNABORTED:             /* hardware forced ep reset */
         case -ECONNRESET:               /* request dequeued */
         case -ESHUTDOWN:                /* disconnect from host */
-                VDBG (dev, "%s gone (%d), %d/%d\n", ep->name, status,
+                VDBG(dev, "%s gone (%d), %d/%d\n", ep->name, status,
                                 req->actual, req->length);
                 if (ep == dev->out_ep)
-                        check_read_data (dev, ep, req);
-                free_ep_req (ep, req);
+                        check_read_data(dev, ep, req);
+                free_ep_req(ep, req);
                 return;
 
         case -EOVERFLOW:                /* buffer overrun on read means that
@@ -557,18 +542,18 @@ static void source_sink_complete (struct usb_ep *ep, struct usb_request *req)
                                          */
         default:
 #if 1
-                DBG (dev, "%s complete --> %d, %d/%d\n", ep->name,
+                DBG(dev, "%s complete --> %d, %d/%d\n", ep->name,
                                 status, req->actual, req->length);
 #endif
         case -EREMOTEIO:                /* short read */
                 break;
         }
 
-        status = usb_ep_queue (ep, req, GFP_ATOMIC);
+        status = usb_ep_queue(ep, req, GFP_ATOMIC);
         if (status) {
-                ERROR (dev, "kill %s:  resubmit %d bytes --> %d\n",
+                ERROR(dev, "kill %s:  resubmit %d bytes --> %d\n",
                                 ep->name, req->length, status);
-                usb_ep_set_halt (ep);
+                usb_ep_set_halt(ep);
                 /* FIXME recover later ... somehow */
         }
 }
@@ -578,24 +563,24 @@ static struct usb_request *source_sink_start_ep(struct usb_ep *ep)
         struct usb_request      *req;
         int                     status;
 
-        req = alloc_ep_req (ep, buflen);
+        req = alloc_ep_req(ep, buflen);
         if (!req)
                 return NULL;
 
-        memset (req->buf, 0, req->length);
+        memset(req->buf, 0, req->length);
         req->complete = source_sink_complete;
 
-        if (strcmp (ep->name, EP_IN_NAME) == 0)
+        if (strcmp(ep->name, EP_IN_NAME) == 0)
                 reinit_write_data(ep, req);
         else
-                memset (req->buf, 0x55, req->length);
+                memset(req->buf, 0x55, req->length);
 
         status = usb_ep_queue(ep, req, GFP_ATOMIC);
         if (status) {
                 struct zero_dev *dev = ep->driver_data;
 
-                ERROR (dev, "start %s --> %d\n", ep->name, status);
-                free_ep_req (ep, req);
+                ERROR(dev, "start %s --> %d\n", ep->name, status);
+                free_ep_req(ep, req);
                 req = NULL;
         }
 
@@ -608,34 +593,34 @@ static int set_source_sink_config(struct zero_dev *dev)
         struct usb_ep           *ep;
         struct usb_gadget       *gadget = dev->gadget;
 
-        gadget_for_each_ep (ep, gadget) {
+        gadget_for_each_ep(ep, gadget) {
                 const struct usb_endpoint_descriptor    *d;
 
                 /* one endpoint writes (sources) zeroes in (to the host) */
-                if (strcmp (ep->name, EP_IN_NAME) == 0) {
-                        d = ep_desc (gadget, &hs_source_desc, &fs_source_desc);
-                        result = usb_ep_enable (ep, d);
+                if (strcmp(ep->name, EP_IN_NAME) == 0) {
+                        d = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
+                        result = usb_ep_enable(ep, d);
                         if (result == 0) {
                                 ep->driver_data = dev;
                                 if (source_sink_start_ep(ep) != NULL) {
                                         dev->in_ep = ep;
                                         continue;
                                 }
-                                usb_ep_disable (ep);
+                                usb_ep_disable(ep);
                                 result = -EIO;
                         }
 
                 /* one endpoint reads (sinks) anything out (from the host) */
-                } else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
-                        d = ep_desc (gadget, &hs_sink_desc, &fs_sink_desc);
-                        result = usb_ep_enable (ep, d);
+                } else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
+                        d = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
+                        result = usb_ep_enable(ep, d);
                         if (result == 0) {
                                 ep->driver_data = dev;
                                 if (source_sink_start_ep(ep) != NULL) {
                                         dev->out_ep = ep;
                                         continue;
                                 }
-                                usb_ep_disable (ep);
+                                usb_ep_disable(ep);
                                 result = -EIO;
                         }
 
@@ -644,11 +629,11 @@ static int set_source_sink_config(struct zero_dev *dev)
                         continue;
 
                 /* stop on error */
-                ERROR (dev, "can't start %s, result %d\n", ep->name, result);
+                ERROR(dev, "can't start %s, result %d\n", ep->name, result);
                 break;
         }
         if (result == 0)
-                DBG (dev, "buflen %d\n", buflen);
+                DBG(dev, "buflen %d\n", buflen);
 
         /* caller is responsible for cleanup on error */
         return result;
@@ -656,7 +641,7 @@ static int set_source_sink_config(struct zero_dev *dev)
 
 /*-------------------------------------------------------------------------*/
 
-static void loopback_complete (struct usb_ep *ep, struct usb_request *req)
+static void loopback_complete(struct usb_ep *ep, struct usb_request *req)
 {
         struct zero_dev *dev = ep->driver_data;
         int             status = req->status;
@@ -668,19 +653,19 @@ static void loopback_complete (struct usb_ep *ep, struct usb_request *req)
                         /* loop this OUT packet back IN to the host */
                         req->zero = (req->actual < req->length);
                         req->length = req->actual;
-                        status = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
+                        status = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);
                         if (status == 0)
                                 return;
 
                         /* "should never get here" */
-                        ERROR (dev, "can't loop %s to %s: %d\n",
+                        ERROR(dev, "can't loop %s to %s: %d\n",
                                 ep->name, dev->in_ep->name,
                                 status);
                 }
 
                 /* queue the buffer for some later OUT packet */
                 req->length = buflen;
-                status = usb_ep_queue (dev->out_ep, req, GFP_ATOMIC);
+                status = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC);
                 if (status == 0)
                         return;
 
@@ -688,7 +673,7 @@ static void loopback_complete (struct usb_ep *ep, struct usb_request *req)
                 /* FALLTHROUGH */
 
         default:
-                ERROR (dev, "%s loop complete --> %d, %d/%d\n", ep->name,
+                ERROR(dev, "%s loop complete --> %d, %d/%d\n", ep->name,
                                 status, req->actual, req->length);
                 /* FALLTHROUGH */
 
@@ -700,7 +685,7 @@ static void loopback_complete (struct usb_ep *ep, struct usb_request *req)
         case -ECONNABORTED:             /* hardware forced ep reset */
         case -ECONNRESET:               /* request dequeued */
         case -ESHUTDOWN:                /* disconnect from host */
-                free_ep_req (ep, req);
+                free_ep_req(ep, req);
                 return;
         }
 }
@@ -711,13 +696,13 @@ static int set_loopback_config(struct zero_dev *dev)
         struct usb_ep           *ep;
         struct usb_gadget       *gadget = dev->gadget;
 
-        gadget_for_each_ep (ep, gadget) {
+        gadget_for_each_ep(ep, gadget) {
                 const struct usb_endpoint_descriptor    *d;
 
                 /* one endpoint writes data back IN to the host */
-                if (strcmp (ep->name, EP_IN_NAME) == 0) {
-                        d = ep_desc (gadget, &hs_source_desc, &fs_source_desc);
-                        result = usb_ep_enable (ep, d);
+                if (strcmp(ep->name, EP_IN_NAME) == 0) {
+                        d = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
+                        result = usb_ep_enable(ep, d);
                         if (result == 0) {
                                 ep->driver_data = dev;
                                 dev->in_ep = ep;
@@ -725,9 +710,9 @@ static int set_loopback_config(struct zero_dev *dev)
                         }
 
                 /* one endpoint just reads OUT packets */
-                } else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
-                        d = ep_desc (gadget, &hs_sink_desc, &fs_sink_desc);
-                        result = usb_ep_enable (ep, d);
+                } else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
+                        d = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
+                        result = usb_ep_enable(ep, d);
                         if (result == 0) {
                                 ep->driver_data = dev;
                                 dev->out_ep = ep;
@@ -739,7 +724,7 @@ static int set_loopback_config(struct zero_dev *dev)
                         continue;
 
                 /* stop on error */
-                ERROR (dev, "can't enable %s, result %d\n", ep->name, result);
+                ERROR(dev, "can't enable %s, result %d\n", ep->name, result);
                 break;
         }
 
@@ -753,19 +738,19 @@ static int set_loopback_config(struct zero_dev *dev)
 
                 ep = dev->out_ep;
                 for (i = 0; i < qlen && result == 0; i++) {
-                        req = alloc_ep_req (ep, buflen);
+                        req = alloc_ep_req(ep, buflen);
                         if (req) {
                                 req->complete = loopback_complete;
-                                result = usb_ep_queue (ep, req, GFP_ATOMIC);
+                                result = usb_ep_queue(ep, req, GFP_ATOMIC);
                                 if (result)
-                                        DBG (dev, "%s queue req --> %d\n",
+                                        DBG(dev, "%s queue req --> %d\n",
                                                         ep->name, result);
                         } else
                                 result = -ENOMEM;
                 }
         }
         if (result == 0)
-                DBG (dev, "qlen %d, buflen %d\n", qlen, buflen);
+                DBG(dev, "qlen %d, buflen %d\n", qlen, buflen);
 
         /* caller is responsible for cleanup on error */
         return result;
@@ -773,26 +758,26 @@ static int set_loopback_config(struct zero_dev *dev)
 
 /*-------------------------------------------------------------------------*/
 
-static void zero_reset_config (struct zero_dev *dev)
+static void zero_reset_config(struct zero_dev *dev)
 {
         if (dev->config == 0)
                 return;
 
-        DBG (dev, "reset config\n");
+        DBG(dev, "reset config\n");
 
         /* just disable endpoints, forcing completion of pending i/o.
          * all our completion handlers free their requests in this case.
          */
         if (dev->in_ep) {
-                usb_ep_disable (dev->in_ep);
+                usb_ep_disable(dev->in_ep);
                 dev->in_ep = NULL;
         }
         if (dev->out_ep) {
-                usb_ep_disable (dev->out_ep);
+                usb_ep_disable(dev->out_ep);
                 dev->out_ep = NULL;
         }
         dev->config = 0;
-        del_timer (&dev->resume);
+        del_timer(&dev->resume);
 }
 
 /* change our operational config.  this code must agree with the code
@@ -813,12 +798,12 @@ static int zero_set_config(struct zero_dev *dev, unsigned number)
         if (number == dev->config)
                 return 0;
 
-        if (gadget_is_sa1100 (gadget) && dev->config) {
+        if (gadget_is_sa1100(gadget) && dev->config) {
                 /* tx fifo is full, but we can't clear it...*/
                 ERROR(dev, "can't change configurations\n");
                 return -ESPIPE;
         }
-        zero_reset_config (dev);
+        zero_reset_config(dev);
 
         switch (number) {
         case CONFIG_SOURCE_SINK:
@@ -837,7 +822,7 @@ static int zero_set_config(struct zero_dev *dev, unsigned number)
         if (!result && (!dev->in_ep || !dev->out_ep))
                 result = -ENODEV;
         if (result)
-                zero_reset_config (dev);
+                zero_reset_config(dev);
         else {
                 char *speed;
 
@@ -849,7 +834,7 @@ static int zero_set_config(struct zero_dev *dev, unsigned number)
                 }
 
                 dev->config = number;
-                INFO (dev, "%s speed config #%d: %s\n", speed, number,
+                INFO(dev, "%s speed config #%d: %s\n", speed, number,
                                 (number == CONFIG_SOURCE_SINK)
                                         ? source_sink : loopback);
         }
@@ -858,10 +843,10 @@ static int zero_set_config(struct zero_dev *dev, unsigned number)
 
 /*-------------------------------------------------------------------------*/
 
-static void zero_setup_complete (struct usb_ep *ep, struct usb_request *req)
+static void zero_setup_complete(struct usb_ep *ep, struct usb_request *req)
 {
         if (req->status || req->actual != req->length)
-                DBG ((struct zero_dev *) ep->driver_data,
+                DBG((struct zero_dev *) ep->driver_data,
                                 "setup complete --> %d, %d/%d\n",
                                 req->status, req->actual, req->length);
 }
@@ -874,9 +859,9 @@ static void zero_setup_complete (struct usb_ep *ep, struct usb_request *req)
  * the work is in config-specific setup.
  */
 static int
-zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
+zero_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 {
-        struct zero_dev         *dev = get_gadget_data (gadget);
+        struct zero_dev         *dev = get_gadget_data(gadget);
         struct usb_request      *req = dev->req;
         int                     value = -EOPNOTSUPP;
         u16                     w_index = le16_to_cpu(ctrl->wIndex);
@@ -895,14 +880,14 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                 switch (w_value >> 8) {
 
                 case USB_DT_DEVICE:
-                        value = min (w_length, (u16) sizeof device_desc);
-                        memcpy (req->buf, &device_desc, value);
+                        value = min(w_length, (u16) sizeof device_desc);
+                        memcpy(req->buf, &device_desc, value);
                         break;
                 case USB_DT_DEVICE_QUALIFIER:
                         if (!gadget_is_dualspeed(gadget))
                                 break;
-                        value = min (w_length, (u16) sizeof dev_qualifier);
-                        memcpy (req->buf, &dev_qualifier, value);
+                        value = min(w_length, (u16) sizeof dev_qualifier);
+                        memcpy(req->buf, &dev_qualifier, value);
                         break;
 
                 case USB_DT_OTHER_SPEED_CONFIG:
@@ -910,11 +895,11 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                                 break;
                         // FALLTHROUGH
                 case USB_DT_CONFIG:
-                        value = config_buf (gadget, req->buf,
+                        value = config_buf(gadget, req->buf,
                                         w_value >> 8,
                                         w_value & 0xff);
                         if (value >= 0)
-                                value = min (w_length, (u16) value);
+                                value = min(w_length, (u16) value);
                         break;
 
                 case USB_DT_STRING:
@@ -923,10 +908,10 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                          * add string tables for other languages, using
                          * any UTF-8 characters
                          */
-                        value = usb_gadget_get_string (&stringtab,
+                        value = usb_gadget_get_string(&stringtab,
                                         w_value & 0xff, req->buf);
                         if (value >= 0)
-                                value = min (w_length, (u16) value);
+                                value = min(w_length, (u16) value);
                         break;
                 }
                 break;
@@ -936,20 +921,20 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                 if (ctrl->bRequestType != 0)
                         goto unknown;
                 if (gadget->a_hnp_support)
-                        DBG (dev, "HNP available\n");
+                        DBG(dev, "HNP available\n");
                 else if (gadget->a_alt_hnp_support)
-                        DBG (dev, "HNP needs a different root port\n");
+                        DBG(dev, "HNP needs a different root port\n");
                 else
-                        VDBG (dev, "HNP inactive\n");
-                spin_lock (&dev->lock);
+                        VDBG(dev, "HNP inactive\n");
+                spin_lock(&dev->lock);
                 value = zero_set_config(dev, w_value);
-                spin_unlock (&dev->lock);
+                spin_unlock(&dev->lock);
                 break;
         case USB_REQ_GET_CONFIGURATION:
                 if (ctrl->bRequestType != USB_DIR_IN)
                         goto unknown;
                 *(u8 *)req->buf = dev->config;
-                value = min (w_length, (u16) 1);
+                value = min(w_length, (u16) 1);
                 break;
 
         /* until we add altsetting support, or other interfaces,
@@ -959,7 +944,7 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
         case USB_REQ_SET_INTERFACE:
                 if (ctrl->bRequestType != USB_RECIP_INTERFACE)
                         goto unknown;
-                spin_lock (&dev->lock);
+                spin_lock(&dev->lock);
                 if (dev->config && w_index == 0 && w_value == 0) {
                         u8              config = dev->config;
 
@@ -970,11 +955,11 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                          * if we had more than one interface we couldn't
                          * use this "reset the config" shortcut.
                          */
-                        zero_reset_config (dev);
+                        zero_reset_config(dev);
                         zero_set_config(dev, config);
                         value = 0;
                 }
-                spin_unlock (&dev->lock);
+                spin_unlock(&dev->lock);
                 break;
         case USB_REQ_GET_INTERFACE:
                 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
@@ -986,7 +971,7 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         break;
                 }
                 *(u8 *)req->buf = 0;
-                value = min (w_length, (u16) 1);
+                value = min(w_length, (u16) 1);
                 break;
 
         /*
@@ -1018,7 +1003,7 @@ zero_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
 
         default:
 unknown:
-                VDBG (dev,
+                VDBG(dev,
                         "unknown control req%02x.%02x v%04x i%04x l%d\n",
                         ctrl->bRequestType, ctrl->bRequest,
                         w_value, w_index, w_length);
@@ -1028,11 +1013,11 @@ unknown:
         if (value >= 0) {
                 req->length = value;
                 req->zero = value < w_length;
-                value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
+                value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
                 if (value < 0) {
-                        DBG (dev, "ep_queue --> %d\n", value);
+                        DBG(dev, "ep_queue --> %d\n", value);
                         req->status = 0;
-                        zero_setup_complete (gadget->ep0, req);
+                        zero_setup_complete(gadget->ep0, req);
                 }
         }
 
@@ -1040,28 +1025,26 @@ unknown:
         return value;
 }
 
-static void
-zero_disconnect (struct usb_gadget *gadget)
+static void zero_disconnect(struct usb_gadget *gadget)
 {
-        struct zero_dev         *dev = get_gadget_data (gadget);
+        struct zero_dev         *dev = get_gadget_data(gadget);
         unsigned long           flags;
 
-        spin_lock_irqsave (&dev->lock, flags);
-        zero_reset_config (dev);
+        spin_lock_irqsave(&dev->lock, flags);
+        zero_reset_config(dev);
 
         /* a more significant application might have some non-usb
          * activities to quiesce here, saving resources like power
          * or pushing the notification up a network stack.
          */
-        spin_unlock_irqrestore (&dev->lock, flags);
+        spin_unlock_irqrestore(&dev->lock, flags);
 
         /* next we may get setup() calls to enumerate new connections;
          * or an unbind() during shutdown (including removing module).
          */
 }
 
-static void
-zero_autoresume (unsigned long _dev)
+static void zero_autoresume(unsigned long _dev)
 {
         struct zero_dev *dev = (struct zero_dev *) _dev;
         int             status;
@@ -1070,32 +1053,30 @@ zero_autoresume (unsigned long _dev)
          * more significant than just a timer firing...
          */
         if (dev->gadget->speed != USB_SPEED_UNKNOWN) {
-                status = usb_gadget_wakeup (dev->gadget);
-                DBG (dev, "wakeup --> %d\n", status);
+                status = usb_gadget_wakeup(dev->gadget);
+                DBG(dev, "wakeup --> %d\n", status);
         }
 }
 
 /*-------------------------------------------------------------------------*/
 
-static void /* __init_or_exit */
-zero_unbind (struct usb_gadget *gadget)
+static void zero_unbind(struct usb_gadget *gadget)
 {
-        struct zero_dev         *dev = get_gadget_data (gadget);
+        struct zero_dev         *dev = get_gadget_data(gadget);
 
-        DBG (dev, "unbind\n");
+        DBG(dev, "unbind\n");
 
         /* we've already been disconnected ... no i/o is active */
         if (dev->req) {
                 dev->req->length = USB_BUFSIZ;
-                free_ep_req (gadget->ep0, dev->req);
+                free_ep_req(gadget->ep0, dev->req);
         }
-        del_timer_sync (&dev->resume);
-        kfree (dev);
-        set_gadget_data (gadget, NULL);
+        del_timer_sync(&dev->resume);
+        kfree(dev);
+        set_gadget_data(gadget, NULL);
 }
 
-static int __init
-zero_bind (struct usb_gadget *gadget)
+static int __init zero_bind(struct usb_gadget *gadget)
 {
         struct zero_dev         *dev;
         struct usb_ep           *ep;
@@ -1111,8 +1092,8 @@ zero_bind (struct usb_gadget *gadget)
          * autoconfigure on any sane usb controller driver,
          * but there may also be important quirks to address.
          */
-        usb_ep_autoconfig_reset (gadget);
-        ep = usb_ep_autoconfig (gadget, &fs_source_desc);
+        usb_ep_autoconfig_reset(gadget);
+        ep = usb_ep_autoconfig(gadget, &fs_source_desc);
         if (!ep) {
 autoconf_fail:
                 pr_err("%s: can't autoconfigure on %s\n",
@@ -1122,15 +1103,15 @@ autoconf_fail:
         EP_IN_NAME = ep->name;
         ep->driver_data = ep;   /* claim */
 
-        ep = usb_ep_autoconfig (gadget, &fs_sink_desc);
+        ep = usb_ep_autoconfig(gadget, &fs_sink_desc);
         if (!ep)
                 goto autoconf_fail;
         EP_OUT_NAME = ep->name;
         ep->driver_data = ep;   /* claim */
 
-        gcnum = usb_gadget_controller_number (gadget);
+        gcnum = usb_gadget_controller_number(gadget);
         if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16 (0x0200 + gcnum);
+                device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
         else {
                 /* gadget zero is so simple (for now, no altsettings) that
                  * it SHOULD NOT have problems with bulk-capable hardware.
@@ -1141,7 +1122,7 @@ autoconf_fail:
                  */
                 pr_warning("%s: controller '%s' not recognized\n",
                         shortname, gadget->name);
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x9999);
+                device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
         }
 
 
@@ -1149,12 +1130,16 @@ autoconf_fail:
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (!dev)
                 return -ENOMEM;
-        spin_lock_init (&dev->lock);
+        spin_lock_init(&dev->lock);
         dev->gadget = gadget;
-        set_gadget_data (gadget, dev);
+        set_gadget_data(gadget, dev);
+
+        init_timer(&dev->resume);
+        dev->resume.function = zero_autoresume;
+        dev->resume.data = (unsigned long) dev;
 
         /* preallocate control response and buffer */
-        dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
+        dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
         if (!dev->req)
                 goto enomem;
         dev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
@@ -1182,11 +1167,8 @@ autoconf_fail:
                 loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        usb_gadget_set_selfpowered (gadget);
+        usb_gadget_set_selfpowered(gadget);
 
-        init_timer (&dev->resume);
-        dev->resume.function = zero_autoresume;
-        dev->resume.data = (unsigned long) dev;
         if (autoresume) {
                 source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
                 loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
@@ -1194,45 +1176,43 @@ autoconf_fail:
 
         gadget->ep0->driver_data = dev;
 
-        INFO (dev, "%s, version: " DRIVER_VERSION "\n", longname);
-        INFO (dev, "using %s, OUT %s IN %s\n", gadget->name,
+        INFO(dev, "%s, version: " DRIVER_VERSION "\n", longname);
+        INFO(dev, "using %s, OUT %s IN %s\n", gadget->name,
                 EP_OUT_NAME, EP_IN_NAME);
 
-        snprintf (manufacturer, sizeof manufacturer, "%s %s with %s",
+        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
                 init_utsname()->sysname, init_utsname()->release,
                 gadget->name);
 
         return 0;
 
 enomem:
-        zero_unbind (gadget);
+        zero_unbind(gadget);
         return -ENOMEM;
 }
 
 /*-------------------------------------------------------------------------*/
 
-static void
-zero_suspend (struct usb_gadget *gadget)
+static void zero_suspend(struct usb_gadget *gadget)
 {
-        struct zero_dev         *dev = get_gadget_data (gadget);
+        struct zero_dev         *dev = get_gadget_data(gadget);
 
         if (gadget->speed == USB_SPEED_UNKNOWN)
                 return;
 
         if (autoresume) {
-                mod_timer (&dev->resume, jiffies + (HZ * autoresume));
-                DBG (dev, "suspend, wakeup in %d seconds\n", autoresume);
+                mod_timer(&dev->resume, jiffies + (HZ * autoresume));
+                DBG(dev, "suspend, wakeup in %d seconds\n", autoresume);
         } else
-                DBG (dev, "suspend\n");
+                DBG(dev, "suspend\n");
 }
 
-static void
-zero_resume (struct usb_gadget *gadget)
+static void zero_resume(struct usb_gadget *gadget)
 {
-        struct zero_dev         *dev = get_gadget_data (gadget);
+        struct zero_dev         *dev = get_gadget_data(gadget);
 
-        DBG (dev, "resume\n");
-        del_timer (&dev->resume);
+        DBG(dev, "resume\n");
+        del_timer(&dev->resume);
 }
 
 
@@ -1264,15 +1244,15 @@ MODULE_AUTHOR("David Brownell");
 MODULE_LICENSE("GPL");
 
 
-static int __init init (void)
+static int __init init(void)
 {
-        return usb_gadget_register_driver (&zero_driver);
+        return usb_gadget_register_driver(&zero_driver);
 }
-module_init (init);
+module_init(init);
 
-static void __exit cleanup (void)
+static void __exit cleanup(void)
 {
-        usb_gadget_unregister_driver (&zero_driver);
+        usb_gadget_unregister_driver(&zero_driver);
 }
-module_exit (cleanup);
+module_exit(cleanup);
 
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 0b87480dd713..228797e54f9c 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -4,6 +4,19 @@
 comment "USB Host Controller Drivers"
         depends on USB
 
+config USB_C67X00_HCD
+        tristate "Cypress C67x00 HCD support"
+        depends on USB
+        help
+          The Cypress C67x00 (EZ-Host/EZ-OTG) chips are dual-role
+          host/peripheral/OTG USB controllers.
+
+          Enable this option to support this chip in host controller mode.
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called c67x00.
+
 config USB_EHCI_HCD
         tristate "EHCI HCD (USB 2.0) support"
         depends on USB && USB_ARCH_HAS_EHCI
@@ -95,6 +108,32 @@ config USB_ISP116X_HCD
           To compile this driver as a module, choose M here: the
           module will be called isp116x-hcd.
 
+config USB_ISP1760_HCD
+        tristate "ISP 1760 HCD support"
+        depends on USB && EXPERIMENTAL
+        ---help---
+          The ISP1760 chip is a USB 2.0 host controller.
+
+          This driver does not support isochronous transfers or OTG.
+
+          To compile this driver as a module, choose M here: the
+          module will be called isp1760-hcd.
+
+config USB_ISP1760_PCI
+        bool "Support for the PCI bus"
+        depends on USB_ISP1760_HCD && PCI
+        ---help---
+          Enables support for the device present on the PCI bus.
+          This should only be required if you happen to have the eval kit from
+          NXP and you are going to test it.
+
+config USB_ISP1760_OF
+        bool "Support for the OF platform bus"
+        depends on USB_ISP1760_HCD && PPC_OF
+        ---help---
+          Enables support for the device present on the PowerPC
+          OpenFirmware platform bus.
+
 config USB_OHCI_HCD
         tristate "OHCI HCD support"
         depends on USB && USB_ARCH_HAS_OHCI
@@ -261,8 +300,8 @@ config USB_R8A66597_HCD
           module will be called r8a66597-hcd.
 
 config SUPERH_ON_CHIP_R8A66597
-        boolean "Enable SuperH on-chip USB like the R8A66597"
-        depends on USB_R8A66597_HCD && CPU_SUBTYPE_SH7366
+        boolean "Enable SuperH on-chip R8A66597 USB"
+        depends on USB_R8A66597_HCD && (CPU_SUBTYPE_SH7366 || CPU_SUBTYPE_SH7723)
         help
-           Renesas SuperH processor has USB like the R8A66597.
-           This driver supported processor is SH7366.
+           This driver enables support for the on-chip R8A66597 in the
+           SH7366 and SH7723 processors.
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index bb8e9d44f371..f1edda2dcfde 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -6,6 +6,8 @@ ifeq ($(CONFIG_USB_DEBUG),y)
         EXTRA_CFLAGS            += -DDEBUG
 endif
 
+isp1760-objs := isp1760-hcd.o isp1760-if.o
+
 obj-$(CONFIG_PCI)               += pci-quirks.o
 
 obj-$(CONFIG_USB_EHCI_HCD)      += ehci-hcd.o
@@ -16,4 +18,4 @@ obj-$(CONFIG_USB_SL811_HCD)	+= sl811-hcd.o
 obj-$(CONFIG_USB_SL811_CS)      += sl811_cs.o
 obj-$(CONFIG_USB_U132_HCD)      += u132-hcd.o
 obj-$(CONFIG_USB_R8A66597_HCD)  += r8a66597-hcd.o
-
+obj-$(CONFIG_USB_ISP1760_HCD)   += isp1760.o
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index 8b5f991e949c..08a4335401a9 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -223,6 +223,7 @@ static const struct hc_driver ehci_au1xxx_hc_driver = {
         .bus_suspend = ehci_bus_suspend,
         .bus_resume = ehci_bus_resume,
         .relinquish_port = ehci_relinquish_port,
+        .port_handed_over = ehci_port_handed_over,
 };
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 6d9bed6c1f48..7370d6187c64 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -269,7 +269,7 @@ static int ehci_fsl_setup(struct usb_hcd *hcd)
         if (retval)
                 return retval;
 
-        ehci->is_tdi_rh_tt = 1;
+        hcd->has_tt = 1;
 
         ehci->sbrn = 0x20;
 
@@ -295,10 +295,6 @@ static const struct hc_driver ehci_fsl_hc_driver = {
          */
         .reset = ehci_fsl_setup,
         .start = ehci_run,
-#ifdef  CONFIG_PM
-        .suspend = ehci_bus_suspend,
-        .resume = ehci_bus_resume,
-#endif
         .stop = ehci_stop,
         .shutdown = ehci_shutdown,
 
@@ -322,6 +318,7 @@ static const struct hc_driver ehci_fsl_hc_driver = {
         .bus_suspend = ehci_bus_suspend,
         .bus_resume = ehci_bus_resume,
         .relinquish_port = ehci_relinquish_port,
+        .port_handed_over = ehci_port_handed_over,
 };
 
 static int ehci_fsl_drv_probe(struct platform_device *pdev)
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 382587c4457c..740835bb8575 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -609,7 +609,7 @@ static int ehci_hub_control (
                         }
                         break;
                 case USB_PORT_FEAT_C_SUSPEND:
-                        /* we auto-clear this feature */
+                        clear_bit(wIndex, &ehci->port_c_suspend);
                         break;
                 case USB_PORT_FEAT_POWER:
                         if (HCS_PPC (ehci->hcs_params))
@@ -688,7 +688,7 @@ static int ehci_hub_control (
                         /* resume completed? */
                         else if (time_after_eq(jiffies,
                                         ehci->reset_done[wIndex])) {
-                                status |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                                set_bit(wIndex, &ehci->port_c_suspend);
                                 ehci->reset_done[wIndex] = 0;
 
                                 /* stop resume signaling */
@@ -765,6 +765,8 @@ static int ehci_hub_control (
                         status |= 1 << USB_PORT_FEAT_RESET;
                 if (temp & PORT_POWER)
                         status |= 1 << USB_PORT_FEAT_POWER;
+                if (test_bit(wIndex, &ehci->port_c_suspend))
+                        status |= 1 << USB_PORT_FEAT_C_SUSPEND;
 
 #ifndef VERBOSE_DEBUG
         if (status & ~0xffff)   /* only if wPortChange is interesting */
@@ -875,3 +877,13 @@ static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum)
         set_owner(ehci, --portnum, PORT_OWNER);
 }
 
+static int ehci_port_handed_over(struct usb_hcd *hcd, int portnum)
+{
+        struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
+        u32 __iomem             *reg;
+
+        if (ehci_is_TDI(ehci))
+                return 0;
+        reg = &ehci->regs->port_status[portnum - 1];
+        return ehci_readl(ehci, reg) & PORT_OWNER;
+}
diff --git a/drivers/usb/host/ehci-ixp4xx.c b/drivers/usb/host/ehci-ixp4xx.c
index 601c8795a854..9d042f220097 100644
--- a/drivers/usb/host/ehci-ixp4xx.c
+++ b/drivers/usb/host/ehci-ixp4xx.c
@@ -26,7 +26,7 @@ static int ixp4xx_ehci_init(struct usb_hcd *hcd)
                 + HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
-        ehci->is_tdi_rh_tt = 1;
+        hcd->has_tt = 1;
         ehci_reset(ehci);
 
         retval = ehci_init(hcd);
@@ -58,6 +58,8 @@ static const struct hc_driver ixp4xx_ehci_hc_driver = {
         .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 ixp4xx_ehci_probe(struct platform_device *pdev)
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index d187d0313742..ab625f0ba1d9 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -115,6 +115,8 @@ static int ehci_orion_setup(struct usb_hcd *hcd)
         if (retval)
                 return retval;
 
+        hcd->has_tt = 1;
+
         ehci_reset(ehci);
         ehci_port_power(ehci, 0);
 
@@ -137,10 +139,6 @@ static const struct hc_driver ehci_orion_hc_driver = {
          */
         .reset = ehci_orion_setup,
         .start = ehci_run,
-#ifdef CONFIG_PM
-        .suspend = ehci_bus_suspend,
-        .resume = ehci_bus_resume,
-#endif
         .stop = ehci_stop,
         .shutdown = ehci_shutdown,
 
@@ -163,6 +161,8 @@ static const struct hc_driver ehci_orion_hc_driver = {
         .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 void __init
@@ -248,7 +248,7 @@ static int __init ehci_orion_drv_probe(struct platform_device *pdev)
         ehci->regs = hcd->regs + 0x100 +
                 HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
-        ehci->is_tdi_rh_tt = 1;
+        hcd->has_tt = 1;
         ehci->sbrn = 0x20;
 
         /*
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 5bb7f6bb13f3..c46a58f9181d 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -129,7 +129,6 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
         switch (pdev->vendor) {
         case PCI_VENDOR_ID_TDI:
                 if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) {
-                        ehci->is_tdi_rh_tt = 1;
                         hcd->has_tt = 1;
                         tdi_reset(ehci);
                 }
@@ -379,7 +378,8 @@ static const struct hc_driver ehci_pci_hc_driver = {
         .hub_control =          ehci_hub_control,
         .bus_suspend =          ehci_bus_suspend,
         .bus_resume =           ehci_bus_resume,
-        .relinquish_port =      ehci_relinquish_port,
+        .relinquish_port =      ehci_relinquish_port,
+        .port_handed_over =     ehci_port_handed_over,
 };
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index ee305b1f99ff..b018deed2e8f 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -76,6 +76,8 @@ static const struct hc_driver ehci_ppc_of_hc_driver = {
         .bus_suspend            = ehci_bus_suspend,
         .bus_resume             = ehci_bus_resume,
 #endif
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
 };
 
 
diff --git a/drivers/usb/host/ehci-ppc-soc.c b/drivers/usb/host/ehci-ppc-soc.c
index 6c76036783a1..529590eb4037 100644
--- a/drivers/usb/host/ehci-ppc-soc.c
+++ b/drivers/usb/host/ehci-ppc-soc.c
@@ -163,6 +163,7 @@ static const struct hc_driver ehci_ppc_soc_hc_driver = {
         .bus_suspend = ehci_bus_suspend,
         .bus_resume = ehci_bus_resume,
         .relinquish_port = ehci_relinquish_port,
+        .port_handed_over = ehci_port_handed_over,
 };
 
 static int ehci_hcd_ppc_soc_drv_probe(struct platform_device *pdev)
diff --git a/drivers/usb/host/ehci-ps3.c b/drivers/usb/host/ehci-ps3.c
index 69782221bcf3..37e6abeb794c 100644
--- a/drivers/usb/host/ehci-ps3.c
+++ b/drivers/usb/host/ehci-ps3.c
@@ -73,6 +73,7 @@ static const struct hc_driver ps3_ehci_hc_driver = {
         .bus_resume             = ehci_bus_resume,
 #endif
         .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
 };
 
 static int ps3_ehci_probe(struct ps3_system_bus_device *dev)
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index be575e46eac3..b7853c8bac0f 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -1349,18 +1349,27 @@ iso_stream_schedule (
         /* when's the last uframe this urb could start? */
         max = now + mod;
 
-        /* typical case: reuse current schedule. stream is still active,
-         * and no gaps from host falling behind (irq delays etc)
+        /* Typical case: reuse current schedule, stream is still active.
+         * Hopefully there are no gaps from the host falling behind
+         * (irq delays etc), but if there are we'll take the next
+         * slot in the schedule, implicitly assuming URB_ISO_ASAP.
          */
         if (likely (!list_empty (&stream->td_list))) {
                 start = stream->next_uframe;
                 if (start < now)
                         start += mod;
-                if (likely ((start + sched->span) < max))
-                        goto ready;
-                /* else fell behind; someday, try to reschedule */
-                status = -EL2NSYNC;
-                goto fail;
+
+                /* Fell behind (by up to twice the slop amount)? */
+                if (start >= max - 2 * 8 * SCHEDULE_SLOP)
+                        start += stream->interval * DIV_ROUND_UP(
+                                        max - start, stream->interval) - mod;
+
+                /* Tried to schedule too far into the future? */
+                if (unlikely((start + sched->span) >= max)) {
+                        status = -EFBIG;
+                        goto fail;
+                }
+                goto ready;
         }
 
         /* need to schedule; when's the next (u)frame we could start?
@@ -1613,6 +1622,9 @@ itd_complete (
                 } else if (likely ((t & EHCI_ISOC_ACTIVE) == 0)) {
                         desc->status = 0;
                         desc->actual_length = EHCI_ITD_LENGTH (t);
+                } else {
+                        /* URB was too late */
+                        desc->status = -EXDEV;
                 }
         }
 
@@ -2095,7 +2107,7 @@ done:
 static void
 scan_periodic (struct ehci_hcd *ehci)
 {
-        unsigned        frame, clock, now_uframe, mod;
+        unsigned        now_uframe, frame, clock, clock_frame, mod;
         unsigned        modified;
 
         mod = ehci->periodic_size << 3;
@@ -2111,6 +2123,7 @@ scan_periodic (struct ehci_hcd *ehci)
         else
                 clock = now_uframe + mod - 1;
         clock %= mod;
+        clock_frame = clock >> 3;
 
         for (;;) {
                 union ehci_shadow       q, *q_p;
@@ -2157,22 +2170,26 @@ restart:
                         case Q_TYPE_ITD:
                                 /* If this ITD is still active, leave it for
                                  * later processing ... check the next entry.
+                                 * No need to check for activity unless the
+                                 * frame is current.
                                  */
-                                rmb ();
-                                for (uf = 0; uf < 8 && live; uf++) {
-                                        if (0 == (q.itd->hw_transaction [uf]
-                                                        & ITD_ACTIVE(ehci)))
-                                                continue;
-                                        incomplete = true;
-                                        q_p = &q.itd->itd_next;
-                                        hw_p = &q.itd->hw_next;
-                                        type = Q_NEXT_TYPE(ehci,
+                                if (frame == clock_frame && live) {
+                                        rmb();
+                                        for (uf = 0; uf < 8; uf++) {
+                                                if (q.itd->hw_transaction[uf] &
+                                                            ITD_ACTIVE(ehci))
+                                                        break;
+                                        }
+                                        if (uf < 8) {
+                                                incomplete = true;
+                                                q_p = &q.itd->itd_next;
+                                                hw_p = &q.itd->hw_next;
+                                                type = Q_NEXT_TYPE(ehci,
                                                         q.itd->hw_next);
-                                        q = *q_p;
-                                        break;
+                                                q = *q_p;
+                                                break;
+                                        }
                                 }
-                                if (uf < 8 && live)
-                                        break;
 
                                 /* Take finished ITDs out of the schedule
                                  * and process them:  recycle, maybe report
@@ -2189,9 +2206,12 @@ restart:
                         case Q_TYPE_SITD:
                                 /* If this SITD is still active, leave it for
                                  * later processing ... check the next entry.
+                                 * No need to check for activity unless the
+                                 * frame is current.
                                  */
-                                if ((q.sitd->hw_results & SITD_ACTIVE(ehci))
-                                                && live) {
+                                if (frame == clock_frame && live &&
+                                                (q.sitd->hw_results &
+                                                        SITD_ACTIVE(ehci))) {
                                         incomplete = true;
                                         q_p = &q.sitd->sitd_next;
                                         hw_p = &q.sitd->hw_next;
@@ -2260,6 +2280,7 @@ restart:
 
                         /* rescan the rest of this frame, then ... */
                         clock = now;
+                        clock_frame = clock >> 3;
                 } else {
                         now_uframe++;
                         now_uframe %= mod;
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index bf92d209a1a9..90245fd8bac4 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -97,6 +97,8 @@ struct ehci_hcd {			/* one per controller */
                         dedicated to the companion controller */
         unsigned long           owned_ports;            /* which ports are
                         owned by the companion during a bus suspend */
+        unsigned long           port_c_suspend;         /* which ports have
+                        the change-suspend feature turned on */
 
         /* per-HC memory pools (could be per-bus, but ...) */
         struct dma_pool         *qh_pool;       /* qh per active urb */
@@ -112,7 +114,6 @@ struct ehci_hcd {			/* one per controller */
         u32                     command;
 
         /* SILICON QUIRKS */
-        unsigned                is_tdi_rh_tt:1; /* TDI roothub with TT */
         unsigned                no_selective_suspend:1;
         unsigned                has_fsl_port_bug:1; /* FreeScale */
         unsigned                big_endian_mmio:1;
@@ -176,6 +177,15 @@ timer_action_done (struct ehci_hcd *ehci, enum ehci_timer_action action)
 static inline void
 timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
 {
+        /* Don't override timeouts which shrink or (later) disable
+         * the async ring; just the I/O watchdog.  Note that if a
+         * SHRINK were pending, OFF would never be requested.
+         */
+        if (timer_pending(&ehci->watchdog)
+                        && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
+                                & ehci->actions))
+                return;
+
         if (!test_and_set_bit (action, &ehci->actions)) {
                 unsigned long t;
 
@@ -191,15 +201,7 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
                         t = EHCI_SHRINK_JIFFIES;
                         break;
                 }
-                t += jiffies;
-                // all timings except IAA watchdog can be overridden.
-                // async queue SHRINK often precedes IAA.  while it's ready
-                // to go OFF neither can matter, and afterwards the IO
-                // watchdog stops unless there's still periodic traffic.
-                if (time_before_eq(t, ehci->watchdog.expires)
-                                && timer_pending (&ehci->watchdog))
-                        return;
-                mod_timer (&ehci->watchdog, t);
+                mod_timer(&ehci->watchdog, t + jiffies);
         }
 }
 
@@ -678,7 +680,7 @@ struct ehci_fstn {
  * needed (mostly in root hub code).
  */
 
-#define ehci_is_TDI(e)                  ((e)->is_tdi_rh_tt)
+#define ehci_is_TDI(e)                  (ehci_to_hcd(e)->has_tt)
 
 /* Returns the speed of a device attached to a port on the root hub. */
 static inline unsigned int
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
new file mode 100644
index 000000000000..65aa5ecf569a
--- /dev/null
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -0,0 +1,2231 @@
+/*
+ * Driver for the NXP ISP1760 chip
+ *
+ * However, the code might contain some bugs. What doesn't work for sure is:
+ * - ISO
+ * - OTG
+ e The interrupt line is configured as active low, level.
+ *
+ * (c) 2007 Sebastian Siewior <bigeasy@linutronix.de>
+ *
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/list.h>
+#include <linux/usb.h>
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <asm/unaligned.h>
+
+#include "../core/hcd.h"
+#include "isp1760-hcd.h"
+
+static struct kmem_cache *qtd_cachep;
+static struct kmem_cache *qh_cachep;
+
+struct isp1760_hcd {
+        u32 hcs_params;
+        spinlock_t              lock;
+        struct inter_packet_info atl_ints[32];
+        struct inter_packet_info int_ints[32];
+        struct memory_chunk memory_pool[BLOCKS];
+
+        /* periodic schedule support */
+#define DEFAULT_I_TDPS          1024
+        unsigned                periodic_size;
+        unsigned                i_thresh;
+        unsigned long           reset_done;
+        unsigned long           next_statechange;
+};
+
+static inline struct isp1760_hcd *hcd_to_priv(struct usb_hcd *hcd)
+{
+        return (struct isp1760_hcd *) (hcd->hcd_priv);
+}
+static inline struct usb_hcd *priv_to_hcd(struct isp1760_hcd *priv)
+{
+        return container_of((void *) priv, struct usb_hcd, hcd_priv);
+}
+
+/* Section 2.2 Host Controller Capability Registers */
+#define HC_LENGTH(p)            (((p)>>00)&0x00ff)      /* bits 7:0 */
+#define HC_VERSION(p)           (((p)>>16)&0xffff)      /* bits 31:16 */
+#define HCS_INDICATOR(p)        ((p)&(1 << 16)) /* true: has port indicators */
+#define HCS_PPC(p)              ((p)&(1 << 4))  /* true: port power control */
+#define HCS_N_PORTS(p)          (((p)>>0)&0xf)  /* bits 3:0, ports on HC */
+#define HCC_ISOC_CACHE(p)       ((p)&(1 << 7))  /* true: can cache isoc frame */
+#define HCC_ISOC_THRES(p)       (((p)>>4)&0x7)  /* bits 6:4, uframes cached */
+
+/* Section 2.3 Host Controller Operational Registers */
+#define CMD_LRESET      (1<<7)          /* partial reset (no ports, etc) */
+#define CMD_RESET       (1<<1)          /* reset HC not bus */
+#define CMD_RUN         (1<<0)          /* start/stop HC */
+#define STS_PCD         (1<<2)          /* port change detect */
+#define FLAG_CF         (1<<0)          /* true: we'll support "high speed" */
+
+#define PORT_OWNER      (1<<13)         /* true: companion hc owns this port */
+#define PORT_POWER      (1<<12)         /* true: has power (see PPC) */
+#define PORT_USB11(x) (((x) & (3 << 10)) == (1 << 10))  /* USB 1.1 device */
+#define PORT_RESET      (1<<8)          /* reset port */
+#define PORT_SUSPEND    (1<<7)          /* suspend port */
+#define PORT_RESUME     (1<<6)          /* resume it */
+#define PORT_PE         (1<<2)          /* port enable */
+#define PORT_CSC        (1<<1)          /* connect status change */
+#define PORT_CONNECT    (1<<0)          /* device connected */
+#define PORT_RWC_BITS   (PORT_CSC)
+
+struct isp1760_qtd {
+        struct isp1760_qtd *hw_next;
+        u8 packet_type;
+        u8 toggle;
+
+        void *data_buffer;
+        /* the rest is HCD-private */
+        struct list_head qtd_list;
+        struct urb *urb;
+        size_t length;
+
+        /* isp special*/
+        u32 status;
+#define URB_COMPLETE_NOTIFY     (1 << 0)
+#define URB_ENQUEUED            (1 << 1)
+#define URB_TYPE_ATL            (1 << 2)
+#define URB_TYPE_INT            (1 << 3)
+};
+
+struct isp1760_qh {
+        /* first part defined by EHCI spec */
+        struct list_head qtd_list;
+        struct isp1760_hcd *priv;
+
+        /* periodic schedule info */
+        unsigned short period;          /* polling interval */
+        struct usb_device *dev;
+
+        u32 toggle;
+        u32 ping;
+};
+
+#define ehci_port_speed(priv, portsc) (1 << USB_PORT_FEAT_HIGHSPEED)
+
+static unsigned int isp1760_readl(__u32 __iomem *regs)
+{
+        return readl(regs);
+}
+
+static void isp1760_writel(const unsigned int val, __u32 __iomem *regs)
+{
+        writel(val, regs);
+}
+
+/*
+ * The next two copy via MMIO data to/from the device. memcpy_{to|from}io()
+ * doesn't quite work because some people have to enforce 32-bit access
+ */
+static void priv_read_copy(struct isp1760_hcd *priv, u32 *src,
+                __u32 __iomem *dst, u32 offset, u32 len)
+{
+        struct usb_hcd *hcd = priv_to_hcd(priv);
+        u32 val;
+        u8 *buff8;
+
+        if (!src) {
+                printk(KERN_ERR "ERROR: buffer: %p len: %d\n", src, len);
+                return;
+        }
+        isp1760_writel(offset,  hcd->regs + HC_MEMORY_REG);
+        /* XXX
+         * 90nsec delay, the spec says something how this could be avoided.
+         */
+        mdelay(1);
+
+        while (len >= 4) {
+                *src = __raw_readl(dst);
+                len -= 4;
+                src++;
+                dst++;
+        }
+
+        if (!len)
+                return;
+
+        /* in case we have 3, 2 or 1 by left. The dst buffer may not be fully
+         * allocated.
+         */
+        val = isp1760_readl(dst);
+
+        buff8 = (u8 *)src;
+        while (len) {
+
+                *buff8 = val;
+                val >>= 8;
+                len--;
+                buff8++;
+        }
+}
+
+static void priv_write_copy(const struct isp1760_hcd *priv, const u32 *src,
+                __u32 __iomem *dst, u32 len)
+{
+        while (len >= 4) {
+                __raw_writel(*src, dst);
+                len -= 4;
+                src++;
+                dst++;
+        }
+
+        if (!len)
+                return;
+        /* in case we have 3, 2 or 1 by left. The buffer is allocated and the
+         * extra bytes should not be read by the HW
+         */
+
+        __raw_writel(*src, dst);
+}
+
+/* memory management of the 60kb on the chip from 0x1000 to 0xffff */
+static void init_memory(struct isp1760_hcd *priv)
+{
+        int i;
+        u32 payload;
+
+        payload = 0x1000;
+        for (i = 0; i < BLOCK_1_NUM; i++) {
+                priv->memory_pool[i].start = payload;
+                priv->memory_pool[i].size = BLOCK_1_SIZE;
+                priv->memory_pool[i].free = 1;
+                payload += priv->memory_pool[i].size;
+        }
+
+
+        for (i = BLOCK_1_NUM; i < BLOCK_1_NUM + BLOCK_2_NUM; i++) {
+                priv->memory_pool[i].start = payload;
+                priv->memory_pool[i].size = BLOCK_2_SIZE;
+                priv->memory_pool[i].free = 1;
+                payload += priv->memory_pool[i].size;
+        }
+
+
+        for (i = BLOCK_1_NUM + BLOCK_2_NUM; i < BLOCKS; i++) {
+                priv->memory_pool[i].start = payload;
+                priv->memory_pool[i].size = BLOCK_3_SIZE;
+                priv->memory_pool[i].free = 1;
+                payload += priv->memory_pool[i].size;
+        }
+
+        BUG_ON(payload - priv->memory_pool[i - 1].size > PAYLOAD_SIZE);
+}
+
+static u32 alloc_mem(struct isp1760_hcd *priv, u32 size)
+{
+        int i;
+
+        if (!size)
+                return ISP1760_NULL_POINTER;
+
+        for (i = 0; i < BLOCKS; i++) {
+                if (priv->memory_pool[i].size >= size &&
+                                priv->memory_pool[i].free) {
+
+                        priv->memory_pool[i].free = 0;
+                        return priv->memory_pool[i].start;
+                }
+        }
+
+        printk(KERN_ERR "ISP1760 MEM: can not allocate %d bytes of memory\n",
+                        size);
+        printk(KERN_ERR "Current memory map:\n");
+        for (i = 0; i < BLOCKS; i++) {
+                printk(KERN_ERR "Pool %2d size %4d status: %d\n",
+                                i, priv->memory_pool[i].size,
+                                priv->memory_pool[i].free);
+        }
+        /* XXX maybe -ENOMEM could be possible */
+        BUG();
+        return 0;
+}
+
+static void free_mem(struct isp1760_hcd *priv, u32 mem)
+{
+        int i;
+
+        if (mem == ISP1760_NULL_POINTER)
+                return;
+
+        for (i = 0; i < BLOCKS; i++) {
+                if (priv->memory_pool[i].start == mem) {
+
+                        BUG_ON(priv->memory_pool[i].free);
+
+                        priv->memory_pool[i].free = 1;
+                        return ;
+                }
+        }
+
+        printk(KERN_ERR "Trying to free not-here-allocated memory :%08x\n",
+                        mem);
+        BUG();
+}
+
+static void isp1760_init_regs(struct usb_hcd *hcd)
+{
+        isp1760_writel(0, hcd->regs + HC_BUFFER_STATUS_REG);
+        isp1760_writel(NO_TRANSFER_ACTIVE, hcd->regs +
+                        HC_ATL_PTD_SKIPMAP_REG);
+        isp1760_writel(NO_TRANSFER_ACTIVE, hcd->regs +
+                        HC_INT_PTD_SKIPMAP_REG);
+        isp1760_writel(NO_TRANSFER_ACTIVE, hcd->regs +
+                        HC_ISO_PTD_SKIPMAP_REG);
+
+        isp1760_writel(~NO_TRANSFER_ACTIVE, hcd->regs +
+                        HC_ATL_PTD_DONEMAP_REG);
+        isp1760_writel(~NO_TRANSFER_ACTIVE, hcd->regs +
+                        HC_INT_PTD_DONEMAP_REG);
+        isp1760_writel(~NO_TRANSFER_ACTIVE, hcd->regs +
+                        HC_ISO_PTD_DONEMAP_REG);
+}
+
+static int handshake(struct isp1760_hcd *priv, void __iomem *ptr,
+                      u32 mask, u32 done, int usec)
+{
+        u32 result;
+
+        do {
+                result = isp1760_readl(ptr);
+                if (result == ~0)
+                        return -ENODEV;
+                result &= mask;
+                if (result == done)
+                        return 0;
+                udelay(1);
+                usec--;
+        } while (usec > 0);
+        return -ETIMEDOUT;
+}
+
+/* reset a non-running (STS_HALT == 1) controller */
+static int ehci_reset(struct isp1760_hcd *priv)
+{
+        int retval;
+        struct usb_hcd *hcd = priv_to_hcd(priv);
+        u32 command = isp1760_readl(hcd->regs + HC_USBCMD);
+
+        command |= CMD_RESET;
+        isp1760_writel(command, hcd->regs + HC_USBCMD);
+        hcd->state = HC_STATE_HALT;
+        priv->next_statechange = jiffies;
+        retval = handshake(priv, hcd->regs + HC_USBCMD,
+                            CMD_RESET, 0, 250 * 1000);
+        return retval;
+}
+
+static void qh_destroy(struct isp1760_qh *qh)
+{
+        BUG_ON(!list_empty(&qh->qtd_list));
+        kmem_cache_free(qh_cachep, qh);
+}
+
+static struct isp1760_qh *isp1760_qh_alloc(struct isp1760_hcd *priv,
+                gfp_t flags)
+{
+        struct isp1760_qh *qh;
+
+        qh = kmem_cache_zalloc(qh_cachep, flags);
+        if (!qh)
+                return qh;
+
+        INIT_LIST_HEAD(&qh->qtd_list);
+        qh->priv = priv;
+        return qh;
+}
+
+/* magic numbers that can affect system performance */
+#define EHCI_TUNE_CERR          3       /* 0-3 qtd retries; 0 == don't stop */
+#define EHCI_TUNE_RL_HS         4       /* nak throttle; see 4.9 */
+#define EHCI_TUNE_RL_TT         0
+#define EHCI_TUNE_MULT_HS       1       /* 1-3 transactions/uframe; 4.10.3 */
+#define EHCI_TUNE_MULT_TT       1
+#define EHCI_TUNE_FLS           2       /* (small) 256 frame schedule */
+
+/* one-time init, only for memory state */
+static int priv_init(struct usb_hcd *hcd)
+{
+        struct isp1760_hcd              *priv = hcd_to_priv(hcd);
+        u32                     hcc_params;
+
+        spin_lock_init(&priv->lock);
+
+        /*
+         * hw default: 1K periodic list heads, one per frame.
+         * periodic_size can shrink by USBCMD update if hcc_params allows.
+         */
+        priv->periodic_size = DEFAULT_I_TDPS;
+
+        /* controllers may cache some of the periodic schedule ... */
+        hcc_params = isp1760_readl(hcd->regs + HC_HCCPARAMS);
+        /* full frame cache */
+        if (HCC_ISOC_CACHE(hcc_params))
+                priv->i_thresh = 8;
+        else /* N microframes cached */
+                priv->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
+
+        return 0;
+}
+
+static int isp1760_hc_setup(struct usb_hcd *hcd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        int result;
+        u32 scratch;
+
+        isp1760_writel(0xdeadbabe, hcd->regs + HC_SCRATCH_REG);
+        scratch = isp1760_readl(hcd->regs + HC_SCRATCH_REG);
+        if (scratch != 0xdeadbabe) {
+                printk(KERN_ERR "ISP1760: Scratch test failed.\n");
+                return -ENODEV;
+        }
+
+        /* pre reset */
+        isp1760_init_regs(hcd);
+
+        /* reset */
+        isp1760_writel(SW_RESET_RESET_ALL, hcd->regs + HC_RESET_REG);
+        mdelay(100);
+
+        isp1760_writel(SW_RESET_RESET_HC, hcd->regs + HC_RESET_REG);
+        mdelay(100);
+
+        result = ehci_reset(priv);
+        if (result)
+                return result;
+
+        /* Step 11 passed */
+
+        isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_REG);
+        isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_ENABLE);
+
+        /* ATL reset */
+        scratch = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
+        isp1760_writel(scratch | ALL_ATX_RESET, hcd->regs + HC_HW_MODE_CTRL);
+        mdelay(10);
+        isp1760_writel(scratch, hcd->regs + HC_HW_MODE_CTRL);
+
+        isp1760_writel(PORT1_POWER | PORT1_INIT2, hcd->regs + HC_PORT1_CTRL);
+        mdelay(10);
+
+        priv->hcs_params = isp1760_readl(hcd->regs + HC_HCSPARAMS);
+
+        return priv_init(hcd);
+}
+
+static void isp1760_init_maps(struct usb_hcd *hcd)
+{
+        /*set last maps, for iso its only 1, else 32 tds bitmap*/
+        isp1760_writel(0x80000000, hcd->regs + HC_ATL_PTD_LASTPTD_REG);
+        isp1760_writel(0x80000000, hcd->regs + HC_INT_PTD_LASTPTD_REG);
+        isp1760_writel(0x00000001, hcd->regs + HC_ISO_PTD_LASTPTD_REG);
+}
+
+static void isp1760_enable_interrupts(struct usb_hcd *hcd)
+{
+        isp1760_writel(0, hcd->regs + HC_ATL_IRQ_MASK_AND_REG);
+        isp1760_writel(0, hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
+        isp1760_writel(0, hcd->regs + HC_INT_IRQ_MASK_AND_REG);
+        isp1760_writel(0, hcd->regs + HC_INT_IRQ_MASK_OR_REG);
+        isp1760_writel(0, hcd->regs + HC_ISO_IRQ_MASK_AND_REG);
+        isp1760_writel(0xffffffff, hcd->regs + HC_ISO_IRQ_MASK_OR_REG);
+        /* step 23 passed */
+}
+
+static int isp1760_run(struct usb_hcd *hcd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        int retval;
+        u32 temp;
+        u32 command;
+        u32 chipid;
+
+        hcd->uses_new_polling = 1;
+        hcd->poll_rh = 0;
+
+        hcd->state = HC_STATE_RUNNING;
+        isp1760_enable_interrupts(hcd);
+        temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
+        temp |= FINAL_HW_CONFIG;
+        isp1760_writel(temp, hcd->regs + HC_HW_MODE_CTRL);
+
+        command = isp1760_readl(hcd->regs + HC_USBCMD);
+        command &= ~(CMD_LRESET|CMD_RESET);
+        command |= CMD_RUN;
+        isp1760_writel(command, hcd->regs + HC_USBCMD);
+
+        retval = handshake(priv, hcd->regs + HC_USBCMD, CMD_RUN, CMD_RUN,
+                        250 * 1000);
+        if (retval)
+                return retval;
+
+        /*
+         * XXX
+         * Spec says to write FLAG_CF as last config action, priv code grabs
+         * the semaphore while doing so.
+         */
+        down_write(&ehci_cf_port_reset_rwsem);
+        isp1760_writel(FLAG_CF, hcd->regs + HC_CONFIGFLAG);
+
+        retval = handshake(priv, hcd->regs + HC_CONFIGFLAG, FLAG_CF, FLAG_CF,
+                        250 * 1000);
+        up_write(&ehci_cf_port_reset_rwsem);
+        if (retval)
+                return retval;
+
+        chipid = isp1760_readl(hcd->regs + HC_CHIP_ID_REG);
+        isp1760_info(priv, "USB ISP %04x HW rev. %d started\n", chipid & 0xffff,
+                        chipid >> 16);
+
+        /* PTD Register Init Part 2, Step 28 */
+        /* enable INTs */
+        isp1760_init_maps(hcd);
+
+        /* GRR this is run-once init(), being done every time the HC starts.
+         * So long as they're part of class devices, we can't do it init()
+         * since the class device isn't created that early.
+         */
+        return 0;
+}
+
+static u32 base_to_chip(u32 base)
+{
+        return ((base - 0x400) >> 3);
+}
+
+static void transform_into_atl(struct isp1760_hcd *priv, struct isp1760_qh *qh,
+                        struct isp1760_qtd *qtd, struct urb *urb,
+                        u32 payload, struct ptd *ptd)
+{
+        u32 dw0;
+        u32 dw1;
+        u32 dw2;
+        u32 dw3;
+        u32 maxpacket;
+        u32 multi;
+        u32 pid_code;
+        u32 rl = RL_COUNTER;
+        u32 nak = NAK_COUNTER;
+
+        /* according to 3.6.2, max packet len can not be > 0x400 */
+        maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
+        multi =  1 + ((maxpacket >> 11) & 0x3);
+        maxpacket &= 0x7ff;
+
+        /* DW0 */
+        dw0 = PTD_VALID;
+        dw0 |= PTD_LENGTH(qtd->length);
+        dw0 |= PTD_MAXPACKET(maxpacket);
+        dw0 |= PTD_ENDPOINT(usb_pipeendpoint(urb->pipe));
+        dw1 = usb_pipeendpoint(urb->pipe) >> 1;
+
+        /* DW1 */
+        dw1 |= PTD_DEVICE_ADDR(usb_pipedevice(urb->pipe));
+
+        pid_code = qtd->packet_type;
+        dw1 |= PTD_PID_TOKEN(pid_code);
+
+        if (usb_pipebulk(urb->pipe))
+                dw1 |= PTD_TRANS_BULK;
+        else if  (usb_pipeint(urb->pipe))
+                dw1 |= PTD_TRANS_INT;
+
+        if (urb->dev->speed != USB_SPEED_HIGH) {
+                /* split transaction */
+
+                dw1 |= PTD_TRANS_SPLIT;
+                if (urb->dev->speed == USB_SPEED_LOW)
+                        dw1 |= PTD_SE_USB_LOSPEED;
+
+                dw1 |= PTD_PORT_NUM(urb->dev->ttport);
+                dw1 |= PTD_HUB_NUM(urb->dev->tt->hub->devnum);
+
+                /* SE bit for Split INT transfers */
+                if (usb_pipeint(urb->pipe) &&
+                                (urb->dev->speed == USB_SPEED_LOW))
+                        dw1 |= 2 << 16;
+
+                dw3 = 0;
+                rl = 0;
+                nak = 0;
+        } else {
+                dw0 |= PTD_MULTI(multi);
+                if (usb_pipecontrol(urb->pipe) || usb_pipebulk(urb->pipe))
+                        dw3 = qh->ping;
+                else
+                        dw3 = 0;
+        }
+        /* DW2 */
+        dw2 = 0;
+        dw2 |= PTD_DATA_START_ADDR(base_to_chip(payload));
+        dw2 |= PTD_RL_CNT(rl);
+        dw3 |= PTD_NAC_CNT(nak);
+
+        /* DW3 */
+        if (usb_pipecontrol(urb->pipe))
+                dw3 |= PTD_DATA_TOGGLE(qtd->toggle);
+        else
+                dw3 |= qh->toggle;
+
+
+        dw3 |= PTD_ACTIVE;
+        /* Cerr */
+        dw3 |= PTD_CERR(ERR_COUNTER);
+
+        memset(ptd, 0, sizeof(*ptd));
+
+        ptd->dw0 = cpu_to_le32(dw0);
+        ptd->dw1 = cpu_to_le32(dw1);
+        ptd->dw2 = cpu_to_le32(dw2);
+        ptd->dw3 = cpu_to_le32(dw3);
+}
+
+static void transform_add_int(struct isp1760_hcd *priv, struct isp1760_qh *qh,
+                        struct isp1760_qtd *qtd, struct urb *urb,
+                        u32 payload, struct ptd *ptd)
+{
+        u32 maxpacket;
+        u32 multi;
+        u32 numberofusofs;
+        u32 i;
+        u32 usofmask, usof;
+        u32 period;
+
+        maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
+        multi =  1 + ((maxpacket >> 11) & 0x3);
+        maxpacket &= 0x7ff;
+        /* length of the data per uframe */
+        maxpacket = multi * maxpacket;
+
+        numberofusofs = urb->transfer_buffer_length / maxpacket;
+        if (urb->transfer_buffer_length % maxpacket)
+                numberofusofs += 1;
+
+        usofmask = 1;
+        usof = 0;
+        for (i = 0; i < numberofusofs; i++) {
+                usof |= usofmask;
+                usofmask <<= 1;
+        }
+
+        if (urb->dev->speed != USB_SPEED_HIGH) {
+                /* split */
+                ptd->dw5 = __constant_cpu_to_le32(0x1c);
+
+                if (qh->period >= 32)
+                        period = qh->period / 2;
+                else
+                        period = qh->period;
+
+        } else {
+
+                if (qh->period >= 8)
+                        period = qh->period/8;
+                else
+                        period = qh->period;
+
+                if (period >= 32)
+                        period  = 16;
+
+                if (qh->period >= 8) {
+                        /* millisecond period */
+                        period = (period << 3);
+                } else {
+                        /* usof based tranmsfers */
+                        /* minimum 4 usofs */
+                        usof = 0x11;
+                }
+        }
+
+        ptd->dw2 |= cpu_to_le32(period);
+        ptd->dw4 = cpu_to_le32(usof);
+}
+
+static void transform_into_int(struct isp1760_hcd *priv, struct isp1760_qh *qh,
+                        struct isp1760_qtd *qtd, struct urb *urb,
+                        u32 payload, struct ptd *ptd)
+{
+        transform_into_atl(priv, qh, qtd, urb, payload, ptd);
+        transform_add_int(priv, qh, qtd, urb,  payload, ptd);
+}
+
+static int qtd_fill(struct isp1760_qtd *qtd, void *databuffer, size_t len,
+                u32 token)
+{
+        int count;
+
+        qtd->data_buffer = databuffer;
+        qtd->packet_type = GET_QTD_TOKEN_TYPE(token);
+        qtd->toggle = GET_DATA_TOGGLE(token);
+
+        if (len > HC_ATL_PL_SIZE)
+                count = HC_ATL_PL_SIZE;
+        else
+                count = len;
+
+        qtd->length = count;
+        return count;
+}
+
+static int check_error(struct ptd *ptd)
+{
+        int error = 0;
+        u32 dw3;
+
+        dw3 = le32_to_cpu(ptd->dw3);
+        if (dw3 & DW3_HALT_BIT)
+                error = -EPIPE;
+
+        if (dw3 & DW3_ERROR_BIT) {
+                printk(KERN_ERR "error bit is set in DW3\n");
+                error = -EPIPE;
+        }
+
+        if (dw3 & DW3_QTD_ACTIVE) {
+                printk(KERN_ERR "transfer active bit is set DW3\n");
+                printk(KERN_ERR "nak counter: %d, rl: %d\n", (dw3 >> 19) & 0xf,
+                                (le32_to_cpu(ptd->dw2) >> 25) & 0xf);
+        }
+
+        return error;
+}
+
+static void check_int_err_status(u32 dw4)
+{
+        u32 i;
+
+        dw4 >>= 8;
+
+        for (i = 0; i < 8; i++) {
+                switch (dw4 & 0x7) {
+                case INT_UNDERRUN:
+                        printk(KERN_ERR "ERROR: under run , %d\n", i);
+                        break;
+
+                case INT_EXACT:
+                        printk(KERN_ERR "ERROR: transaction error, %d\n", i);
+                        break;
+
+                case INT_BABBLE:
+                        printk(KERN_ERR "ERROR: babble error, %d\n", i);
+                        break;
+                }
+                dw4 >>= 3;
+        }
+}
+
+static void enqueue_one_qtd(struct isp1760_qtd *qtd, struct isp1760_hcd *priv,
+                u32 payload)
+{
+        u32 token;
+        struct usb_hcd *hcd = priv_to_hcd(priv);
+
+        token = qtd->packet_type;
+
+        if (qtd->length && (qtd->length <= HC_ATL_PL_SIZE)) {
+                switch (token) {
+                case IN_PID:
+                        break;
+                case OUT_PID:
+                case SETUP_PID:
+                        priv_write_copy(priv, qtd->data_buffer,
+                                        hcd->regs + payload,
+                                        qtd->length);
+                }
+        }
+}
+
+static void enqueue_one_atl_qtd(u32 atl_regs, u32 payload,
+                struct isp1760_hcd *priv, struct isp1760_qh *qh,
+                struct urb *urb, u32 slot, struct isp1760_qtd *qtd)
+{
+        struct ptd ptd;
+        struct usb_hcd *hcd = priv_to_hcd(priv);
+
+        transform_into_atl(priv, qh, qtd, urb, payload, &ptd);
+        priv_write_copy(priv, (u32 *)&ptd, hcd->regs + atl_regs, sizeof(ptd));
+        enqueue_one_qtd(qtd, priv, payload);
+
+        priv->atl_ints[slot].urb = urb;
+        priv->atl_ints[slot].qh = qh;
+        priv->atl_ints[slot].qtd = qtd;
+        priv->atl_ints[slot].data_buffer = qtd->data_buffer;
+        priv->atl_ints[slot].payload = payload;
+        qtd->status |= URB_ENQUEUED | URB_TYPE_ATL;
+        qtd->status |= slot << 16;
+}
+
+static void enqueue_one_int_qtd(u32 int_regs, u32 payload,
+                struct isp1760_hcd *priv, struct isp1760_qh *qh,
+                struct urb *urb, u32 slot,  struct isp1760_qtd *qtd)
+{
+        struct ptd ptd;
+        struct usb_hcd *hcd = priv_to_hcd(priv);
+
+        transform_into_int(priv, qh, qtd, urb, payload, &ptd);
+        priv_write_copy(priv, (u32 *)&ptd, hcd->regs + int_regs, sizeof(ptd));
+        enqueue_one_qtd(qtd, priv, payload);
+
+        priv->int_ints[slot].urb = urb;
+        priv->int_ints[slot].qh = qh;
+        priv->int_ints[slot].qtd = qtd;
+        priv->int_ints[slot].data_buffer = qtd->data_buffer;
+        priv->int_ints[slot].payload = payload;
+        qtd->status |= URB_ENQUEUED | URB_TYPE_INT;
+        qtd->status |= slot << 16;
+}
+
+void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
+                struct isp1760_qtd *qtd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        u32 skip_map, or_map;
+        u32 queue_entry;
+        u32 slot;
+        u32 atl_regs, payload;
+        u32 buffstatus;
+
+        skip_map = isp1760_readl(hcd->regs + HC_ATL_PTD_SKIPMAP_REG);
+
+        BUG_ON(!skip_map);
+        slot = __ffs(skip_map);
+        queue_entry = 1 << slot;
+
+        atl_regs = ATL_REGS_OFFSET + slot * sizeof(struct ptd);
+
+        payload = alloc_mem(priv, qtd->length);
+
+        enqueue_one_atl_qtd(atl_regs, payload, priv, qh, qtd->urb, slot, qtd);
+
+        or_map = isp1760_readl(hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
+        or_map |= queue_entry;
+        isp1760_writel(or_map, hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
+
+        skip_map &= ~queue_entry;
+        isp1760_writel(skip_map, hcd->regs + HC_ATL_PTD_SKIPMAP_REG);
+
+        buffstatus = isp1760_readl(hcd->regs + HC_BUFFER_STATUS_REG);
+        buffstatus |= ATL_BUFFER;
+        isp1760_writel(buffstatus, hcd->regs + HC_BUFFER_STATUS_REG);
+}
+
+void enqueue_an_INT_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
+                struct isp1760_qtd *qtd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        u32 skip_map, or_map;
+        u32 queue_entry;
+        u32 slot;
+        u32 int_regs, payload;
+        u32 buffstatus;
+
+        skip_map = isp1760_readl(hcd->regs + HC_INT_PTD_SKIPMAP_REG);
+
+        BUG_ON(!skip_map);
+        slot = __ffs(skip_map);
+        queue_entry = 1 << slot;
+
+        int_regs = INT_REGS_OFFSET + slot * sizeof(struct ptd);
+
+        payload = alloc_mem(priv, qtd->length);
+
+        enqueue_one_int_qtd(int_regs, payload, priv, qh, qtd->urb, slot, qtd);
+
+        or_map = isp1760_readl(hcd->regs + HC_INT_IRQ_MASK_OR_REG);
+        or_map |= queue_entry;
+        isp1760_writel(or_map, hcd->regs + HC_INT_IRQ_MASK_OR_REG);
+
+        skip_map &= ~queue_entry;
+        isp1760_writel(skip_map, hcd->regs + HC_INT_PTD_SKIPMAP_REG);
+
+        buffstatus = isp1760_readl(hcd->regs + HC_BUFFER_STATUS_REG);
+        buffstatus |= INT_BUFFER;
+        isp1760_writel(buffstatus, hcd->regs + HC_BUFFER_STATUS_REG);
+}
+
+static void isp1760_urb_done(struct isp1760_hcd *priv, struct urb *urb, int status)
+__releases(priv->lock)
+__acquires(priv->lock)
+{
+        if (!urb->unlinked) {
+                if (status == -EINPROGRESS)
+                        status = 0;
+        }
+
+        /* complete() can reenter this HCD */
+        usb_hcd_unlink_urb_from_ep(priv_to_hcd(priv), urb);
+        spin_unlock(&priv->lock);
+        usb_hcd_giveback_urb(priv_to_hcd(priv), urb, status);
+        spin_lock(&priv->lock);
+}
+
+static void isp1760_qtd_free(struct isp1760_qtd *qtd)
+{
+        kmem_cache_free(qtd_cachep, qtd);
+}
+
+static struct isp1760_qtd *clean_this_qtd(struct isp1760_qtd *qtd)
+{
+        struct isp1760_qtd *tmp_qtd;
+
+        tmp_qtd = qtd->hw_next;
+        list_del(&qtd->qtd_list);
+        isp1760_qtd_free(qtd);
+        return tmp_qtd;
+}
+
+/*
+ * Remove this QTD from the QH list and free its memory. If this QTD
+ * isn't the last one than remove also his successor(s).
+ * Returns the QTD which is part of an new URB and should be enqueued.
+ */
+static struct isp1760_qtd *clean_up_qtdlist(struct isp1760_qtd *qtd)
+{
+        struct isp1760_qtd *tmp_qtd;
+        int last_one;
+
+        do {
+                tmp_qtd = qtd->hw_next;
+                last_one = qtd->status & URB_COMPLETE_NOTIFY;
+                list_del(&qtd->qtd_list);
+                isp1760_qtd_free(qtd);
+                qtd = tmp_qtd;
+        } while (!last_one && qtd);
+
+        return qtd;
+}
+
+static void do_atl_int(struct usb_hcd *usb_hcd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
+        u32 done_map, skip_map;
+        struct ptd ptd;
+        struct urb *urb = NULL;
+        u32 atl_regs_base;
+        u32 atl_regs;
+        u32 queue_entry;
+        u32 payload;
+        u32 length;
+        u32 or_map;
+        u32 status = -EINVAL;
+        int error;
+        struct isp1760_qtd *qtd;
+        struct isp1760_qh *qh;
+        u32 rl;
+        u32 nakcount;
+
+        done_map = isp1760_readl(usb_hcd->regs +
+                        HC_ATL_PTD_DONEMAP_REG);
+        skip_map = isp1760_readl(usb_hcd->regs +
+                        HC_ATL_PTD_SKIPMAP_REG);
+
+        or_map = isp1760_readl(usb_hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
+        or_map &= ~done_map;
+        isp1760_writel(or_map, usb_hcd->regs + HC_ATL_IRQ_MASK_OR_REG);
+
+        atl_regs_base = ATL_REGS_OFFSET;
+        while (done_map) {
+                u32 dw1;
+                u32 dw2;
+                u32 dw3;
+
+                status = 0;
+
+                queue_entry = __ffs(done_map);
+                done_map &= ~(1 << queue_entry);
+                skip_map |= 1 << queue_entry;
+
+                atl_regs = atl_regs_base + queue_entry * sizeof(struct ptd);
+
+                urb = priv->atl_ints[queue_entry].urb;
+                qtd = priv->atl_ints[queue_entry].qtd;
+                qh = priv->atl_ints[queue_entry].qh;
+                payload = priv->atl_ints[queue_entry].payload;
+
+                if (!qh) {
+                        printk(KERN_ERR "qh is 0\n");
+                        continue;
+                }
+                priv_read_copy(priv, (u32 *)&ptd, usb_hcd->regs + atl_regs,
+                                atl_regs, sizeof(ptd));
+
+                dw1 = le32_to_cpu(ptd.dw1);
+                dw2 = le32_to_cpu(ptd.dw2);
+                dw3 = le32_to_cpu(ptd.dw3);
+                rl = (dw2 >> 25) & 0x0f;
+                nakcount = (dw3 >> 19) & 0xf;
+
+                /* Transfer Error, *but* active and no HALT -> reload */
+                if ((dw3 & DW3_ERROR_BIT) && (dw3 & DW3_QTD_ACTIVE) &&
+                                !(dw3 & DW3_HALT_BIT)) {
+
+                        /* according to ppriv code, we have to
+                         * reload this one if trasfered bytes != requested bytes
+                         * else act like everything went smooth..
+                         * XXX This just doesn't feel right and hasn't
+                         * triggered so far.
+                         */
+
+                        length = PTD_XFERRED_LENGTH(dw3);
+                        printk(KERN_ERR "Should reload now.... transfered %d "
+                                        "of %zu\n", length, qtd->length);
+                        BUG();
+                }
+
+                if (!nakcount && (dw3 & DW3_QTD_ACTIVE)) {
+                        u32 buffstatus;
+
+                        /* XXX
+                         * NAKs are handled in HW by the chip. Usually if the
+                         * device is not able to send data fast enough.
+                         * This did not trigger for a long time now.
+                         */
+                        printk(KERN_ERR "Reloading ptd %p/%p... qh %p readed: "
+                                        "%d of %zu done: %08x cur: %08x\n", qtd,
+                                        urb, qh, PTD_XFERRED_LENGTH(dw3),
+                                        qtd->length, done_map,
+                                        (1 << queue_entry));
+
+                        /* RL counter = ERR counter */
+                        dw3 &= ~(0xf << 19);
+                        dw3 |= rl << 19;
+                        dw3 &= ~(3 << (55 - 32));
+                        dw3 |= ERR_COUNTER << (55 - 32);
+
+                        /*
+                         * It is not needed to write skip map back because it
+                         * is unchanged. Just make sure that this entry is
+                         * unskipped once it gets written to the HW.
+                         */
+                        skip_map &= ~(1 << queue_entry);
+                        or_map = isp1760_readl(usb_hcd->regs +
+                                        HC_ATL_IRQ_MASK_OR_REG);
+                        or_map |= 1 << queue_entry;
+                        isp1760_writel(or_map, usb_hcd->regs +
+                                        HC_ATL_IRQ_MASK_OR_REG);
+
+                        ptd.dw3 = cpu_to_le32(dw3);
+                        priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
+                                        atl_regs, sizeof(ptd));
+
+                        ptd.dw0 |= __constant_cpu_to_le32(PTD_VALID);
+                        priv_write_copy(priv, (u32 *)&ptd, usb_hcd->regs +
+                                        atl_regs, sizeof(ptd));
+
+                        buffstatus = isp1760_readl(usb_hcd->regs +
+                                        HC_BUFFER_STATUS_REG);
+                        buffstatus |= ATL_BUFFER;
+                        isp1760_writel(buffstatus, usb_hcd->regs +
+                                        HC_BUFFER_STATUS_REG);
+                        continue;
+                }
+
+                error = check_error(&ptd);
+                if (error) {
+                        status = error;
+                        priv->atl_ints[queue_entry].qh->toggle = 0;
+                        priv->atl_ints[queue_entry].qh->ping = 0;
+                        urb->status = -EPIPE;
+
+#if 0
+                        printk(KERN_ERR "Error in %s().\n", __func__);
+                        printk(KERN_ERR "IN dw0: %08x dw1: %08x dw2: %08x "
+                                        "dw3: %08x dw4: %08x dw5: %08x dw6: "
+                                        "%08x dw7: %08x\n",
+                                        ptd.dw0, ptd.dw1, ptd.dw2, ptd.dw3,
+                                        ptd.dw4, ptd.dw5, ptd.dw6, ptd.dw7);
+#endif
+                } else {
+                        if (usb_pipetype(urb->pipe) == PIPE_BULK) {
+                                priv->atl_ints[queue_entry].qh->toggle = dw3 &
+                                        (1 << 25);
+                                priv->atl_ints[queue_entry].qh->ping = dw3 &
+                                        (1 << 26);
+                        }
+                }
+
+                length = PTD_XFERRED_LENGTH(dw3);
+                if (length) {
+                        switch (DW1_GET_PID(dw1)) {
+                        case IN_PID:
+                                priv_read_copy(priv,
+                                        priv->atl_ints[queue_entry].data_buffer,
+                                        usb_hcd->regs + payload, payload,
+                                        length);
+
+                        case OUT_PID:
+
+                                urb->actual_length += length;
+
+                        case SETUP_PID:
+                                break;
+                        }
+                }
+
+                priv->atl_ints[queue_entry].data_buffer = NULL;
+                priv->atl_ints[queue_entry].urb = NULL;
+                priv->atl_ints[queue_entry].qtd = NULL;
+                priv->atl_ints[queue_entry].qh = NULL;
+
+                free_mem(priv, payload);
+
+                isp1760_writel(skip_map, usb_hcd->regs +
+                                HC_ATL_PTD_SKIPMAP_REG);
+
+                if (urb->status == -EPIPE) {
+                        /* HALT was received */
+
+                        qtd = clean_up_qtdlist(qtd);
+                        isp1760_urb_done(priv, urb, urb->status);
+
+                } else if (usb_pipebulk(urb->pipe) && (length < qtd->length)) {
+                        /* short BULK received */
+
+                        printk(KERN_ERR "short bulk, %d instead %zu\n", length,
+                                        qtd->length);
+                        if (urb->transfer_flags & URB_SHORT_NOT_OK) {
+                                urb->status = -EREMOTEIO;
+                                printk(KERN_ERR "not okey\n");
+                        }
+
+                        if (urb->status == -EINPROGRESS)
+                                urb->status = 0;
+
+                        qtd = clean_up_qtdlist(qtd);
+
+                        isp1760_urb_done(priv, urb, urb->status);
+
+                } else if (qtd->status & URB_COMPLETE_NOTIFY) {
+                        /* that was the last qtd of that URB */
+
+                        if (urb->status == -EINPROGRESS)
+                                urb->status = 0;
+
+                        qtd = clean_this_qtd(qtd);
+                        isp1760_urb_done(priv, urb, urb->status);
+
+                } else {
+                        /* next QTD of this URB */
+
+                        qtd = clean_this_qtd(qtd);
+                        BUG_ON(!qtd);
+                }
+
+                if (qtd)
+                        enqueue_an_ATL_packet(usb_hcd, qh, qtd);
+
+                skip_map = isp1760_readl(usb_hcd->regs +
+                                HC_ATL_PTD_SKIPMAP_REG);
+        }
+}
+
+static void do_intl_int(struct usb_hcd *usb_hcd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
+        u32 done_map, skip_map;
+        struct ptd ptd;
+        struct urb *urb = NULL;
+        u32 int_regs;
+        u32 int_regs_base;
+        u32 payload;
+        u32 length;
+        u32 or_map;
+        int error;
+        u32 queue_entry;
+        struct isp1760_qtd *qtd;
+        struct isp1760_qh *qh;
+
+        done_map = isp1760_readl(usb_hcd->regs +
+                        HC_INT_PTD_DONEMAP_REG);
+        skip_map = isp1760_readl(usb_hcd->regs +
+                        HC_INT_PTD_SKIPMAP_REG);
+
+        or_map = isp1760_readl(usb_hcd->regs + HC_INT_IRQ_MASK_OR_REG);
+        or_map &= ~done_map;
+        isp1760_writel(or_map, usb_hcd->regs + HC_INT_IRQ_MASK_OR_REG);
+
+        int_regs_base = INT_REGS_OFFSET;
+
+        while (done_map) {
+                u32 dw1;
+                u32 dw3;
+
+                queue_entry = __ffs(done_map);
+                done_map &= ~(1 << queue_entry);
+                skip_map |= 1 << queue_entry;
+
+                int_regs = int_regs_base + queue_entry * sizeof(struct ptd);
+                urb = priv->int_ints[queue_entry].urb;
+                qtd = priv->int_ints[queue_entry].qtd;
+                qh = priv->int_ints[queue_entry].qh;
+                payload = priv->int_ints[queue_entry].payload;
+
+                if (!qh) {
+                        printk(KERN_ERR "(INT) qh is 0\n");
+                        continue;
+                }
+
+                priv_read_copy(priv, (u32 *)&ptd, usb_hcd->regs + int_regs,
+                                int_regs, sizeof(ptd));
+                dw1 = le32_to_cpu(ptd.dw1);
+                dw3 = le32_to_cpu(ptd.dw3);
+                check_int_err_status(le32_to_cpu(ptd.dw4));
+
+                error = check_error(&ptd);
+                if (error) {
+#if 0
+                        printk(KERN_ERR "Error in %s().\n", __func__);
+                        printk(KERN_ERR "IN dw0: %08x dw1: %08x dw2: %08x "
+                                        "dw3: %08x dw4: %08x dw5: %08x dw6: "
+                                        "%08x dw7: %08x\n",
+                                        ptd.dw0, ptd.dw1, ptd.dw2, ptd.dw3,
+                                        ptd.dw4, ptd.dw5, ptd.dw6, ptd.dw7);
+#endif
+                        urb->status = -EPIPE;
+                        priv->int_ints[queue_entry].qh->toggle = 0;
+                        priv->int_ints[queue_entry].qh->ping = 0;
+
+                } else {
+                        priv->int_ints[queue_entry].qh->toggle =
+                                dw3 & (1 << 25);
+                        priv->int_ints[queue_entry].qh->ping = dw3 & (1 << 26);
+                }
+
+                if (urb->dev->speed != USB_SPEED_HIGH)
+                        length = PTD_XFERRED_LENGTH_LO(dw3);
+                else
+                        length = PTD_XFERRED_LENGTH(dw3);
+
+                if (length) {
+                        switch (DW1_GET_PID(dw1)) {
+                        case IN_PID:
+                                priv_read_copy(priv,
+                                        priv->int_ints[queue_entry].data_buffer,
+                                        usb_hcd->regs + payload , payload,
+                                        length);
+                        case OUT_PID:
+
+                                urb->actual_length += length;
+
+                        case SETUP_PID:
+                                break;
+                        }
+                }
+
+                priv->int_ints[queue_entry].data_buffer = NULL;
+                priv->int_ints[queue_entry].urb = NULL;
+                priv->int_ints[queue_entry].qtd = NULL;
+                priv->int_ints[queue_entry].qh = NULL;
+
+                isp1760_writel(skip_map, usb_hcd->regs +
+                                HC_INT_PTD_SKIPMAP_REG);
+                free_mem(priv, payload);
+
+                if (urb->status == -EPIPE) {
+                        /* HALT received */
+
+                         qtd = clean_up_qtdlist(qtd);
+                         isp1760_urb_done(priv, urb, urb->status);
+
+                } else if (qtd->status & URB_COMPLETE_NOTIFY) {
+
+                        if (urb->status == -EINPROGRESS)
+                                urb->status = 0;
+
+                        qtd = clean_this_qtd(qtd);
+                        isp1760_urb_done(priv, urb, urb->status);
+
+                } else {
+                        /* next QTD of this URB */
+
+                        qtd = clean_this_qtd(qtd);
+                        BUG_ON(!qtd);
+                }
+
+                if (qtd)
+                        enqueue_an_INT_packet(usb_hcd, qh, qtd);
+
+                skip_map = isp1760_readl(usb_hcd->regs +
+                                HC_INT_PTD_SKIPMAP_REG);
+        }
+}
+
+#define max_packet(wMaxPacketSize) ((wMaxPacketSize) & 0x07ff)
+static struct isp1760_qh *qh_make(struct isp1760_hcd *priv, struct urb *urb,
+                gfp_t flags)
+{
+        struct isp1760_qh *qh;
+        int is_input, type;
+
+        qh = isp1760_qh_alloc(priv, flags);
+        if (!qh)
+                return qh;
+
+        /*
+         * init endpoint/device data for this QH
+         */
+        is_input = usb_pipein(urb->pipe);
+        type = usb_pipetype(urb->pipe);
+
+        if (type == PIPE_INTERRUPT) {
+
+                if (urb->dev->speed == USB_SPEED_HIGH) {
+
+                        qh->period = urb->interval >> 3;
+                        if (qh->period == 0 && urb->interval != 1) {
+                                /* NOTE interval 2 or 4 uframes could work.
+                                 * But interval 1 scheduling is simpler, and
+                                 * includes high bandwidth.
+                                 */
+                                printk(KERN_ERR "intr period %d uframes, NYET!",
+                                                urb->interval);
+                                qh_destroy(qh);
+                                return NULL;
+                        }
+                } else {
+                        qh->period = urb->interval;
+                }
+        }
+
+        /* support for tt scheduling, and access to toggles */
+        qh->dev = urb->dev;
+
+        if (!usb_pipecontrol(urb->pipe))
+                usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), !is_input,
+                                1);
+        return qh;
+}
+
+/*
+ * For control/bulk/interrupt, return QH with these TDs appended.
+ * Allocates and initializes the QH if necessary.
+ * Returns null if it can't allocate a QH it needs to.
+ * If the QH has TDs (urbs) already, that's great.
+ */
+static struct isp1760_qh *qh_append_tds(struct isp1760_hcd *priv,
+                struct urb *urb, struct list_head *qtd_list, int epnum,
+                void **ptr)
+{
+        struct isp1760_qh *qh;
+        struct isp1760_qtd *qtd;
+        struct isp1760_qtd *prev_qtd;
+
+        qh = (struct isp1760_qh *)*ptr;
+        if (!qh) {
+                /* can't sleep here, we have priv->lock... */
+                qh = qh_make(priv, urb, GFP_ATOMIC);
+                if (!qh)
+                        return qh;
+                *ptr = qh;
+        }
+
+        qtd = list_entry(qtd_list->next, struct isp1760_qtd,
+                        qtd_list);
+        if (!list_empty(&qh->qtd_list))
+                prev_qtd = list_entry(qh->qtd_list.prev,
+                                struct isp1760_qtd, qtd_list);
+        else
+                prev_qtd = NULL;
+
+        list_splice(qtd_list, qh->qtd_list.prev);
+        if (prev_qtd) {
+                BUG_ON(prev_qtd->hw_next);
+                prev_qtd->hw_next = qtd;
+        }
+
+        urb->hcpriv = qh;
+        return qh;
+}
+
+static void qtd_list_free(struct isp1760_hcd *priv, struct urb *urb,
+                struct list_head *qtd_list)
+{
+        struct list_head *entry, *temp;
+
+        list_for_each_safe(entry, temp, qtd_list) {
+                struct isp1760_qtd      *qtd;
+
+                qtd = list_entry(entry, struct isp1760_qtd, qtd_list);
+                list_del(&qtd->qtd_list);
+                isp1760_qtd_free(qtd);
+        }
+}
+
+static int isp1760_prepare_enqueue(struct isp1760_hcd *priv, struct urb *urb,
+                struct list_head *qtd_list, gfp_t mem_flags, packet_enqueue *p)
+{
+        struct isp1760_qtd         *qtd;
+        int                     epnum;
+        unsigned long           flags;
+        struct isp1760_qh          *qh = NULL;
+        int                     rc;
+        int qh_busy;
+
+        qtd = list_entry(qtd_list->next, struct isp1760_qtd, qtd_list);
+        epnum = urb->ep->desc.bEndpointAddress;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &priv_to_hcd(priv)->flags)) {
+                rc = -ESHUTDOWN;
+                goto done;
+        }
+        rc = usb_hcd_link_urb_to_ep(priv_to_hcd(priv), urb);
+        if (rc)
+                goto done;
+
+        qh = urb->ep->hcpriv;
+        if (qh)
+                qh_busy = !list_empty(&qh->qtd_list);
+        else
+                qh_busy = 0;
+
+        qh = qh_append_tds(priv, urb, qtd_list, epnum, &urb->ep->hcpriv);
+        if (!qh) {
+                usb_hcd_unlink_urb_from_ep(priv_to_hcd(priv), urb);
+                rc = -ENOMEM;
+                goto done;
+        }
+
+        if (!qh_busy)
+                p(priv_to_hcd(priv), qh, qtd);
+
+done:
+        spin_unlock_irqrestore(&priv->lock, flags);
+        if (!qh)
+                qtd_list_free(priv, urb, qtd_list);
+        return rc;
+}
+
+static struct isp1760_qtd *isp1760_qtd_alloc(struct isp1760_hcd *priv,
+                gfp_t flags)
+{
+        struct isp1760_qtd *qtd;
+
+        qtd = kmem_cache_zalloc(qtd_cachep, flags);
+        if (qtd)
+                INIT_LIST_HEAD(&qtd->qtd_list);
+
+        return qtd;
+}
+
+/*
+ * create a list of filled qtds for this URB; won't link into qh.
+ */
+static struct list_head *qh_urb_transaction(struct isp1760_hcd *priv,
+                struct urb *urb, struct list_head *head, gfp_t flags)
+{
+        struct isp1760_qtd *qtd, *qtd_prev;
+        void *buf;
+        int len, maxpacket;
+        int is_input;
+        u32 token;
+
+        /*
+         * URBs map to sequences of QTDs:  one logical transaction
+         */
+        qtd = isp1760_qtd_alloc(priv, flags);
+        if (!qtd)
+                return NULL;
+
+        list_add_tail(&qtd->qtd_list, head);
+        qtd->urb = urb;
+        urb->status = -EINPROGRESS;
+
+        token = 0;
+        /* for split transactions, SplitXState initialized to zero */
+
+        len = urb->transfer_buffer_length;
+        is_input = usb_pipein(urb->pipe);
+        if (usb_pipecontrol(urb->pipe)) {
+                /* SETUP pid */
+                qtd_fill(qtd, urb->setup_packet,
+                                sizeof(struct usb_ctrlrequest),
+                                token | SETUP_PID);
+
+                /* ... and always at least one more pid */
+                token ^= DATA_TOGGLE;
+                qtd_prev = qtd;
+                qtd = isp1760_qtd_alloc(priv, flags);
+                if (!qtd)
+                        goto cleanup;
+                qtd->urb = urb;
+                qtd_prev->hw_next = qtd;
+                list_add_tail(&qtd->qtd_list, head);
+
+                /* for zero length DATA stages, STATUS is always IN */
+                if (len == 0)
+                        token |= IN_PID;
+        }
+
+        /*
+         * data transfer stage:  buffer setup
+         */
+        buf = urb->transfer_buffer;
+
+        if (is_input)
+                token |= IN_PID;
+        else
+                token |= OUT_PID;
+
+        maxpacket = max_packet(usb_maxpacket(urb->dev, urb->pipe, !is_input));
+
+        /*
+         * buffer gets wrapped in one or more qtds;
+         * last one may be "short" (including zero len)
+         * and may serve as a control status ack
+         */
+        for (;;) {
+                int this_qtd_len;
+
+                if (!buf && len) {
+                        /* XXX This looks like usb storage / SCSI bug */
+                        printk(KERN_ERR "buf is null, dma is %08lx len is %d\n",
+                                        (long unsigned)urb->transfer_dma, len);
+                        WARN_ON(1);
+                }
+
+                this_qtd_len = qtd_fill(qtd, buf, len, token);
+                len -= this_qtd_len;
+                buf += this_qtd_len;
+
+                /* qh makes control packets use qtd toggle; maybe switch it */
+                if ((maxpacket & (this_qtd_len + (maxpacket - 1))) == 0)
+                        token ^= DATA_TOGGLE;
+
+                if (len <= 0)
+                        break;
+
+                qtd_prev = qtd;
+                qtd = isp1760_qtd_alloc(priv, flags);
+                if (!qtd)
+                        goto cleanup;
+                qtd->urb = urb;
+                qtd_prev->hw_next = qtd;
+                list_add_tail(&qtd->qtd_list, head);
+        }
+
+        /*
+         * control requests may need a terminating data "status" ack;
+         * bulk ones may need a terminating short packet (zero length).
+         */
+        if (urb->transfer_buffer_length != 0) {
+                int one_more = 0;
+
+                if (usb_pipecontrol(urb->pipe)) {
+                        one_more = 1;
+                        /* "in" <--> "out"  */
+                        token ^= IN_PID;
+                        /* force DATA1 */
+                        token |= DATA_TOGGLE;
+                } else if (usb_pipebulk(urb->pipe)
+                                && (urb->transfer_flags & URB_ZERO_PACKET)
+                                && !(urb->transfer_buffer_length % maxpacket)) {
+                        one_more = 1;
+                }
+                if (one_more) {
+                        qtd_prev = qtd;
+                        qtd = isp1760_qtd_alloc(priv, flags);
+                        if (!qtd)
+                                goto cleanup;
+                        qtd->urb = urb;
+                        qtd_prev->hw_next = qtd;
+                        list_add_tail(&qtd->qtd_list, head);
+
+                        /* never any data in such packets */
+                        qtd_fill(qtd, NULL, 0, token);
+                }
+        }
+
+        qtd->status = URB_COMPLETE_NOTIFY;
+        return head;
+
+cleanup:
+        qtd_list_free(priv, urb, head);
+        return NULL;
+}
+
+static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
+                gfp_t mem_flags)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        struct list_head qtd_list;
+        packet_enqueue *pe;
+
+        INIT_LIST_HEAD(&qtd_list);
+
+        switch (usb_pipetype(urb->pipe)) {
+        case PIPE_CONTROL:
+        case PIPE_BULK:
+
+                if (!qh_urb_transaction(priv, urb, &qtd_list, mem_flags))
+                        return -ENOMEM;
+                pe =  enqueue_an_ATL_packet;
+                break;
+
+        case PIPE_INTERRUPT:
+                if (!qh_urb_transaction(priv, urb, &qtd_list, mem_flags))
+                        return -ENOMEM;
+                pe = enqueue_an_INT_packet;
+                break;
+
+        case PIPE_ISOCHRONOUS:
+                printk(KERN_ERR "PIPE_ISOCHRONOUS ain't supported\n");
+        default:
+                return -EPIPE;
+        }
+
+        isp1760_prepare_enqueue(priv, urb, &qtd_list, mem_flags, pe);
+        return 0;
+}
+
+static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
+                int status)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        struct inter_packet_info *ints;
+        u32 i;
+        u32 reg_base, or_reg, skip_reg;
+        int flags;
+        struct ptd ptd;
+
+        switch (usb_pipetype(urb->pipe)) {
+        case PIPE_ISOCHRONOUS:
+                return -EPIPE;
+                break;
+
+        case PIPE_INTERRUPT:
+                ints = priv->int_ints;
+                reg_base = INT_REGS_OFFSET;
+                or_reg = HC_INT_IRQ_MASK_OR_REG;
+                skip_reg = HC_INT_PTD_SKIPMAP_REG;
+                break;
+
+        default:
+                ints = priv->atl_ints;
+                reg_base = ATL_REGS_OFFSET;
+                or_reg = HC_ATL_IRQ_MASK_OR_REG;
+                skip_reg = HC_ATL_PTD_SKIPMAP_REG;
+                break;
+        }
+
+        memset(&ptd, 0, sizeof(ptd));
+        spin_lock_irqsave(&priv->lock, flags);
+
+        for (i = 0; i < 32; i++) {
+                if (ints->urb == urb) {
+                        u32 skip_map;
+                        u32 or_map;
+                        struct isp1760_qtd *qtd;
+
+                        skip_map = isp1760_readl(hcd->regs + skip_reg);
+                        skip_map |= 1 << i;
+                        isp1760_writel(skip_map, hcd->regs + skip_reg);
+
+                        or_map = isp1760_readl(hcd->regs + or_reg);
+                        or_map &= ~(1 << i);
+                        isp1760_writel(or_map, hcd->regs + or_reg);
+
+                        priv_write_copy(priv, (u32 *)&ptd, hcd->regs + reg_base
+                                        + i * sizeof(ptd), sizeof(ptd));
+                        qtd = ints->qtd;
+
+                        clean_up_qtdlist(qtd);
+
+                        free_mem(priv, ints->payload);
+
+                        ints->urb = NULL;
+                        ints->qh = NULL;
+                        ints->qtd = NULL;
+                        ints->data_buffer = NULL;
+                        ints->payload = 0;
+
+                        isp1760_urb_done(priv, urb, status);
+                        break;
+                }
+                ints++;
+        }
+
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return 0;
+}
+
+static irqreturn_t isp1760_irq(struct usb_hcd *usb_hcd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
+        u32 imask;
+        irqreturn_t irqret = IRQ_NONE;
+
+        spin_lock(&priv->lock);
+
+        if (!(usb_hcd->state & HC_STATE_RUNNING))
+                goto leave;
+
+        imask = isp1760_readl(usb_hcd->regs + HC_INTERRUPT_REG);
+        if (unlikely(!imask))
+                goto leave;
+
+        isp1760_writel(imask, usb_hcd->regs + HC_INTERRUPT_REG);
+        if (imask & HC_ATL_INT)
+                do_atl_int(usb_hcd);
+
+        if (imask & HC_INTL_INT)
+                do_intl_int(usb_hcd);
+
+        irqret = IRQ_HANDLED;
+leave:
+        spin_unlock(&priv->lock);
+        return irqret;
+}
+
+static int isp1760_hub_status_data(struct usb_hcd *hcd, char *buf)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        u32 temp, status = 0;
+        u32 mask;
+        int retval = 1;
+        unsigned long flags;
+
+        /* if !USB_SUSPEND, root hub timers won't get shut down ... */
+        if (!HC_IS_RUNNING(hcd->state))
+                return 0;
+
+        /* init status to no-changes */
+        buf[0] = 0;
+        mask = PORT_CSC;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        temp = isp1760_readl(hcd->regs + HC_PORTSC1);
+
+        if (temp & PORT_OWNER) {
+                if (temp & PORT_CSC) {
+                        temp &= ~PORT_CSC;
+                        isp1760_writel(temp, hcd->regs + HC_PORTSC1);
+                        goto done;
+                }
+        }
+
+        /*
+         * Return status information even for ports with OWNER set.
+         * Otherwise khubd wouldn't see the disconnect event when a
+         * high-speed device is switched over to the companion
+         * controller by the user.
+         */
+
+        if ((temp & mask) != 0
+                        || ((temp & PORT_RESUME) != 0
+                                && time_after_eq(jiffies,
+                                        priv->reset_done))) {
+                buf [0] |= 1 << (0 + 1);
+                status = STS_PCD;
+        }
+        /* FIXME autosuspend idle root hubs */
+done:
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return status ? retval : 0;
+}
+
+static void isp1760_hub_descriptor(struct isp1760_hcd *priv,
+                struct usb_hub_descriptor *desc)
+{
+        int ports = HCS_N_PORTS(priv->hcs_params);
+        u16 temp;
+
+        desc->bDescriptorType = 0x29;
+        /* priv 1.0, 2.3.9 says 20ms max */
+        desc->bPwrOn2PwrGood = 10;
+        desc->bHubContrCurrent = 0;
+
+        desc->bNbrPorts = ports;
+        temp = 1 + (ports / 8);
+        desc->bDescLength = 7 + 2 * temp;
+
+        /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
+        memset(&desc->bitmap[0], 0, temp);
+        memset(&desc->bitmap[temp], 0xff, temp);
+
+        /* per-port overcurrent reporting */
+        temp = 0x0008;
+        if (HCS_PPC(priv->hcs_params))
+                /* per-port power control */
+                temp |= 0x0001;
+        else
+                /* no power switching */
+                temp |= 0x0002;
+        desc->wHubCharacteristics = cpu_to_le16(temp);
+}
+
+#define PORT_WAKE_BITS  (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
+
+static int check_reset_complete(struct isp1760_hcd *priv, int index,
+                u32 __iomem *status_reg, int port_status)
+{
+        if (!(port_status & PORT_CONNECT))
+                return port_status;
+
+        /* if reset finished and it's still not enabled -- handoff */
+        if (!(port_status & PORT_PE)) {
+
+                printk(KERN_ERR "port %d full speed --> companion\n",
+                        index + 1);
+
+                port_status |= PORT_OWNER;
+                port_status &= ~PORT_RWC_BITS;
+                isp1760_writel(port_status, status_reg);
+
+        } else
+                printk(KERN_ERR "port %d high speed\n", index + 1);
+
+        return port_status;
+}
+
+static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
+                u16 wValue, u16 wIndex, char *buf, u16 wLength)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        int ports = HCS_N_PORTS(priv->hcs_params);
+        u32 __iomem *status_reg = hcd->regs + HC_PORTSC1;
+        u32 temp, status;
+        unsigned long flags;
+        int retval = 0;
+        unsigned selector;
+
+        /*
+         * FIXME:  support SetPortFeatures USB_PORT_FEAT_INDICATOR.
+         * HCS_INDICATOR may say we can change LEDs to off/amber/green.
+         * (track current state ourselves) ... blink for diagnostics,
+         * power, "this is the one", etc.  EHCI spec supports this.
+         */
+
+        spin_lock_irqsave(&priv->lock, flags);
+        switch (typeReq) {
+        case ClearHubFeature:
+                switch (wValue) {
+                case C_HUB_LOCAL_POWER:
+                case C_HUB_OVER_CURRENT:
+                        /* no hub-wide feature/status flags */
+                        break;
+                default:
+                        goto error;
+                }
+                break;
+        case ClearPortFeature:
+                if (!wIndex || wIndex > ports)
+                        goto error;
+                wIndex--;
+                temp = isp1760_readl(status_reg);
+
+                /*
+                 * Even if OWNER is set, so the port is owned by the
+                 * companion controller, khubd needs to be able to clear
+                 * the port-change status bits (especially
+                 * USB_PORT_FEAT_C_CONNECTION).
+                 */
+
+                switch (wValue) {
+                case USB_PORT_FEAT_ENABLE:
+                        isp1760_writel(temp & ~PORT_PE, status_reg);
+                        break;
+                case USB_PORT_FEAT_C_ENABLE:
+                        /* XXX error? */
+                        break;
+                case USB_PORT_FEAT_SUSPEND:
+                        if (temp & PORT_RESET)
+                                goto error;
+
+                        if (temp & PORT_SUSPEND) {
+                                if ((temp & PORT_PE) == 0)
+                                        goto error;
+                                /* resume signaling for 20 msec */
+                                temp &= ~(PORT_RWC_BITS);
+                                isp1760_writel(temp | PORT_RESUME,
+                                                status_reg);
+                                priv->reset_done = jiffies +
+                                        msecs_to_jiffies(20);
+                        }
+                        break;
+                case USB_PORT_FEAT_C_SUSPEND:
+                        /* we auto-clear this feature */
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        if (HCS_PPC(priv->hcs_params))
+                                isp1760_writel(temp & ~PORT_POWER, status_reg);
+                        break;
+                case USB_PORT_FEAT_C_CONNECTION:
+                        isp1760_writel(temp | PORT_CSC,
+                                        status_reg);
+                        break;
+                case USB_PORT_FEAT_C_OVER_CURRENT:
+                        /* XXX error ?*/
+                        break;
+                case USB_PORT_FEAT_C_RESET:
+                        /* GetPortStatus clears reset */
+                        break;
+                default:
+                        goto error;
+                }
+                isp1760_readl(hcd->regs + HC_USBCMD);
+                break;
+        case GetHubDescriptor:
+                isp1760_hub_descriptor(priv, (struct usb_hub_descriptor *)
+                        buf);
+                break;
+        case GetHubStatus:
+                /* no hub-wide feature/status flags */
+                memset(buf, 0, 4);
+                break;
+        case GetPortStatus:
+                if (!wIndex || wIndex > ports)
+                        goto error;
+                wIndex--;
+                status = 0;
+                temp = isp1760_readl(status_reg);
+
+                /* wPortChange bits */
+                if (temp & PORT_CSC)
+                        status |= 1 << USB_PORT_FEAT_C_CONNECTION;
+
+
+                /* whoever resumes must GetPortStatus to complete it!! */
+                if (temp & PORT_RESUME) {
+                        printk(KERN_ERR "Port resume should be skipped.\n");
+
+                        /* Remote Wakeup received? */
+                        if (!priv->reset_done) {
+                                /* resume signaling for 20 msec */
+                                priv->reset_done = jiffies
+                                                + msecs_to_jiffies(20);
+                                /* check the port again */
+                                mod_timer(&priv_to_hcd(priv)->rh_timer,
+                                                priv->reset_done);
+                        }
+
+                        /* resume completed? */
+                        else if (time_after_eq(jiffies,
+                                        priv->reset_done)) {
+                                status |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                                priv->reset_done = 0;
+
+                                /* stop resume signaling */
+                                temp = isp1760_readl(status_reg);
+                                isp1760_writel(
+                                        temp & ~(PORT_RWC_BITS | PORT_RESUME),
+                                        status_reg);
+                                retval = handshake(priv, status_reg,
+                                           PORT_RESUME, 0, 2000 /* 2msec */);
+                                if (retval != 0) {
+                                        isp1760_err(priv,
+                                                "port %d resume error %d\n",
+                                                wIndex + 1, retval);
+                                        goto error;
+                                }
+                                temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10));
+                        }
+                }
+
+                /* whoever resets must GetPortStatus to complete it!! */
+                if ((temp & PORT_RESET)
+                                && time_after_eq(jiffies,
+                                        priv->reset_done)) {
+                        status |= 1 << USB_PORT_FEAT_C_RESET;
+                        priv->reset_done = 0;
+
+                        /* force reset to complete */
+                        isp1760_writel(temp & ~PORT_RESET,
+                                        status_reg);
+                        /* REVISIT:  some hardware needs 550+ usec to clear
+                         * this bit; seems too long to spin routinely...
+                         */
+                        retval = handshake(priv, status_reg,
+                                        PORT_RESET, 0, 750);
+                        if (retval != 0) {
+                                isp1760_err(priv, "port %d reset error %d\n",
+                                                wIndex + 1, retval);
+                                goto error;
+                        }
+
+                        /* see what we found out */
+                        temp = check_reset_complete(priv, wIndex, status_reg,
+                                        isp1760_readl(status_reg));
+                }
+                /*
+                 * Even if OWNER is set, there's no harm letting khubd
+                 * see the wPortStatus values (they should all be 0 except
+                 * for PORT_POWER anyway).
+                 */
+
+                if (temp & PORT_OWNER)
+                        printk(KERN_ERR "Warning: PORT_OWNER is set\n");
+
+                if (temp & PORT_CONNECT) {
+                        status |= 1 << USB_PORT_FEAT_CONNECTION;
+                        /* status may be from integrated TT */
+                        status |= ehci_port_speed(priv, temp);
+                }
+                if (temp & PORT_PE)
+                        status |= 1 << USB_PORT_FEAT_ENABLE;
+                if (temp & (PORT_SUSPEND|PORT_RESUME))
+                        status |= 1 << USB_PORT_FEAT_SUSPEND;
+                if (temp & PORT_RESET)
+                        status |= 1 << USB_PORT_FEAT_RESET;
+                if (temp & PORT_POWER)
+                        status |= 1 << USB_PORT_FEAT_POWER;
+
+                put_unaligned(cpu_to_le32(status), (__le32 *) buf);
+                break;
+        case SetHubFeature:
+                switch (wValue) {
+                case C_HUB_LOCAL_POWER:
+                case C_HUB_OVER_CURRENT:
+                        /* no hub-wide feature/status flags */
+                        break;
+                default:
+                        goto error;
+                }
+                break;
+        case SetPortFeature:
+                selector = wIndex >> 8;
+                wIndex &= 0xff;
+                if (!wIndex || wIndex > ports)
+                        goto error;
+                wIndex--;
+                temp = isp1760_readl(status_reg);
+                if (temp & PORT_OWNER)
+                        break;
+
+/*              temp &= ~PORT_RWC_BITS; */
+                switch (wValue) {
+                case USB_PORT_FEAT_ENABLE:
+                        isp1760_writel(temp | PORT_PE, status_reg);
+                        break;
+
+                case USB_PORT_FEAT_SUSPEND:
+                        if ((temp & PORT_PE) == 0
+                                        || (temp & PORT_RESET) != 0)
+                                goto error;
+
+                        isp1760_writel(temp | PORT_SUSPEND, status_reg);
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        if (HCS_PPC(priv->hcs_params))
+                                isp1760_writel(temp | PORT_POWER,
+                                                status_reg);
+                        break;
+                case USB_PORT_FEAT_RESET:
+                        if (temp & PORT_RESUME)
+                                goto error;
+                        /* line status bits may report this as low speed,
+                         * which can be fine if this root hub has a
+                         * transaction translator built in.
+                         */
+                        if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
+                                        && PORT_USB11(temp)) {
+                                temp |= PORT_OWNER;
+                        } else {
+                                temp |= PORT_RESET;
+                                temp &= ~PORT_PE;
+
+                                /*
+                                 * caller must wait, then call GetPortStatus
+                                 * usb 2.0 spec says 50 ms resets on root
+                                 */
+                                priv->reset_done = jiffies +
+                                        msecs_to_jiffies(50);
+                        }
+                        isp1760_writel(temp, status_reg);
+                        break;
+                default:
+                        goto error;
+                }
+                isp1760_readl(hcd->regs + HC_USBCMD);
+                break;
+
+        default:
+error:
+                /* "stall" on error */
+                retval = -EPIPE;
+        }
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return retval;
+}
+
+static void isp1760_endpoint_disable(struct usb_hcd *usb_hcd,
+                struct usb_host_endpoint *ep)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
+        struct isp1760_qh *qh;
+        struct isp1760_qtd *qtd;
+        u32 flags;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        qh = ep->hcpriv;
+        if (!qh)
+                goto out;
+
+        ep->hcpriv = NULL;
+        do {
+                /* more than entry might get removed */
+                if (list_empty(&qh->qtd_list))
+                        break;
+
+                qtd = list_first_entry(&qh->qtd_list, struct isp1760_qtd,
+                                qtd_list);
+
+                if (qtd->status & URB_ENQUEUED) {
+
+                        spin_unlock_irqrestore(&priv->lock, flags);
+                        isp1760_urb_dequeue(usb_hcd, qtd->urb, -ECONNRESET);
+                        spin_lock_irqsave(&priv->lock, flags);
+                } else {
+                        struct urb *urb;
+
+                        urb = qtd->urb;
+                        clean_up_qtdlist(qtd);
+                        isp1760_urb_done(priv, urb, -ECONNRESET);
+                }
+        } while (1);
+
+        qh_destroy(qh);
+        /* remove requests and leak them.
+         * ATL are pretty fast done, INT could take a while...
+         * The latter shoule be removed
+         */
+out:
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static int isp1760_get_frame(struct usb_hcd *hcd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        u32 fr;
+
+        fr = isp1760_readl(hcd->regs + HC_FRINDEX);
+        return (fr >> 3) % priv->periodic_size;
+}
+
+static void isp1760_stop(struct usb_hcd *hcd)
+{
+        struct isp1760_hcd *priv = hcd_to_priv(hcd);
+
+        isp1760_hub_control(hcd, ClearPortFeature, USB_PORT_FEAT_POWER, 1,
+                        NULL, 0);
+        mdelay(20);
+
+        spin_lock_irq(&priv->lock);
+        ehci_reset(priv);
+        /* Disable IRQ */
+        isp1760_writel(HW_DATA_BUS_32BIT, hcd->regs + HC_HW_MODE_CTRL);
+        spin_unlock_irq(&priv->lock);
+
+        isp1760_writel(0, hcd->regs + HC_CONFIGFLAG);
+}
+
+static void isp1760_shutdown(struct usb_hcd *hcd)
+{
+        u32 command;
+
+        isp1760_stop(hcd);
+        isp1760_writel(HW_DATA_BUS_32BIT, hcd->regs + HC_HW_MODE_CTRL);
+
+        command = isp1760_readl(hcd->regs + HC_USBCMD);
+        command &= ~CMD_RUN;
+        isp1760_writel(command, hcd->regs + HC_USBCMD);
+}
+
+static const struct hc_driver isp1760_hc_driver = {
+        .description            = "isp1760-hcd",
+        .product_desc           = "NXP ISP1760 USB Host Controller",
+        .hcd_priv_size          = sizeof(struct isp1760_hcd),
+        .irq                    = isp1760_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+        .reset                  = isp1760_hc_setup,
+        .start                  = isp1760_run,
+        .stop                   = isp1760_stop,
+        .shutdown               = isp1760_shutdown,
+        .urb_enqueue            = isp1760_urb_enqueue,
+        .urb_dequeue            = isp1760_urb_dequeue,
+        .endpoint_disable       = isp1760_endpoint_disable,
+        .get_frame_number       = isp1760_get_frame,
+        .hub_status_data        = isp1760_hub_status_data,
+        .hub_control            = isp1760_hub_control,
+};
+
+int __init init_kmem_once(void)
+{
+        qtd_cachep = kmem_cache_create("isp1760_qtd",
+                        sizeof(struct isp1760_qtd), 0, SLAB_TEMPORARY |
+                        SLAB_MEM_SPREAD, NULL);
+
+        if (!qtd_cachep)
+                return -ENOMEM;
+
+        qh_cachep = kmem_cache_create("isp1760_qh", sizeof(struct isp1760_qh),
+                        0, SLAB_TEMPORARY | SLAB_MEM_SPREAD, NULL);
+
+        if (!qh_cachep) {
+                kmem_cache_destroy(qtd_cachep);
+                return -ENOMEM;
+        }
+
+        return 0;
+}
+
+void deinit_kmem_cache(void)
+{
+        kmem_cache_destroy(qtd_cachep);
+        kmem_cache_destroy(qh_cachep);
+}
+
+struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
+                u64 irqflags, struct device *dev, const char *busname)
+{
+        struct usb_hcd *hcd;
+        struct isp1760_hcd *priv;
+        int ret;
+
+        if (usb_disabled())
+                return ERR_PTR(-ENODEV);
+
+        /* prevent usb-core allocating DMA pages */
+        dev->dma_mask = NULL;
+
+        hcd = usb_create_hcd(&isp1760_hc_driver, dev, dev->bus_id);
+        if (!hcd)
+                return ERR_PTR(-ENOMEM);
+
+        priv = hcd_to_priv(hcd);
+        init_memory(priv);
+        hcd->regs = ioremap(res_start, res_len);
+        if (!hcd->regs) {
+                ret = -EIO;
+                goto err_put;
+        }
+
+        hcd->irq = irq;
+        hcd->rsrc_start = res_start;
+        hcd->rsrc_len = res_len;
+
+        ret = usb_add_hcd(hcd, irq, irqflags);
+        if (ret)
+                goto err_unmap;
+
+        return hcd;
+
+err_unmap:
+         iounmap(hcd->regs);
+
+err_put:
+         usb_put_hcd(hcd);
+
+         return ERR_PTR(ret);
+}
+
+MODULE_DESCRIPTION("Driver for the ISP1760 USB-controller from NXP");
+MODULE_AUTHOR("Sebastian Siewior <bigeasy@linuxtronix.de>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h
new file mode 100644
index 000000000000..3d86d0f6b147
--- /dev/null
+++ b/drivers/usb/host/isp1760-hcd.h
@@ -0,0 +1,206 @@
+#ifndef _ISP1760_HCD_H_
+#define _ISP1760_HCD_H_
+
+/* exports for if */
+struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
+                u64 irqflags, struct device *dev, const char *busname);
+int init_kmem_once(void);
+void deinit_kmem_cache(void);
+
+/* EHCI capability registers */
+#define HC_CAPLENGTH            0x00
+#define HC_HCSPARAMS            0x04
+#define HC_HCCPARAMS            0x08
+
+/* EHCI operational registers */
+#define HC_USBCMD               0x20
+#define HC_USBSTS               0x24
+#define HC_FRINDEX              0x2c
+#define HC_CONFIGFLAG           0x60
+#define HC_PORTSC1              0x64
+#define HC_ISO_PTD_DONEMAP_REG  0x130
+#define HC_ISO_PTD_SKIPMAP_REG  0x134
+#define HC_ISO_PTD_LASTPTD_REG  0x138
+#define HC_INT_PTD_DONEMAP_REG  0x140
+#define HC_INT_PTD_SKIPMAP_REG  0x144
+#define HC_INT_PTD_LASTPTD_REG  0x148
+#define HC_ATL_PTD_DONEMAP_REG  0x150
+#define HC_ATL_PTD_SKIPMAP_REG  0x154
+#define HC_ATL_PTD_LASTPTD_REG  0x158
+
+/* Configuration Register */
+#define HC_HW_MODE_CTRL         0x300
+#define ALL_ATX_RESET           (1 << 31)
+#define HW_DATA_BUS_32BIT       (1 << 8)
+#define HW_DACK_POL_HIGH        (1 << 6)
+#define HW_DREQ_POL_HIGH        (1 << 5)
+#define HW_INTR_HIGH_ACT        (1 << 2)
+#define HW_INTR_EDGE_TRIG       (1 << 1)
+#define HW_GLOBAL_INTR_EN       (1 << 0)
+
+#define HC_CHIP_ID_REG          0x304
+#define HC_SCRATCH_REG          0x308
+
+#define HC_RESET_REG            0x30c
+#define SW_RESET_RESET_HC       (1 << 1)
+#define SW_RESET_RESET_ALL      (1 << 0)
+
+#define HC_BUFFER_STATUS_REG    0x334
+#define ATL_BUFFER              0x1
+#define INT_BUFFER              0x2
+#define ISO_BUFFER              0x4
+#define BUFFER_MAP              0x7
+
+#define HC_MEMORY_REG           0x33c
+#define HC_PORT1_CTRL           0x374
+#define PORT1_POWER             (3 << 3)
+#define PORT1_INIT1             (1 << 7)
+#define PORT1_INIT2             (1 << 23)
+
+/* Interrupt Register */
+#define HC_INTERRUPT_REG        0x310
+
+#define HC_INTERRUPT_ENABLE     0x314
+#define INTERRUPT_ENABLE_MASK   (HC_INTL_INT | HC_ATL_INT | HC_EOT_INT)
+#define FINAL_HW_CONFIG (HW_GLOBAL_INTR_EN | HW_DATA_BUS_32BIT)
+
+#define HC_ISO_INT              (1 << 9)
+#define HC_ATL_INT              (1 << 8)
+#define HC_INTL_INT             (1 << 7)
+#define HC_EOT_INT              (1 << 3)
+#define HC_SOT_INT              (1 << 1)
+
+#define HC_ISO_IRQ_MASK_OR_REG  0x318
+#define HC_INT_IRQ_MASK_OR_REG  0x31C
+#define HC_ATL_IRQ_MASK_OR_REG  0x320
+#define HC_ISO_IRQ_MASK_AND_REG 0x324
+#define HC_INT_IRQ_MASK_AND_REG 0x328
+#define HC_ATL_IRQ_MASK_AND_REG 0x32C
+
+/* Register sets */
+#define HC_BEGIN_OF_ATL         0x0c00
+#define HC_BEGIN_OF_INT         0x0800
+#define HC_BEGIN_OF_ISO         0x0400
+#define HC_BEGIN_OF_PAYLOAD     0x1000
+
+/* urb state*/
+#define DELETE_URB              (0x0008)
+#define NO_TRANSFER_ACTIVE      (0xffffffff)
+
+#define ATL_REGS_OFFSET         (0xc00)
+#define INT_REGS_OFFSET         (0x800)
+
+/* Philips Transfer Descriptor (PTD) */
+struct ptd {
+        __le32 dw0;
+        __le32 dw1;
+        __le32 dw2;
+        __le32 dw3;
+        __le32 dw4;
+        __le32 dw5;
+        __le32 dw6;
+        __le32 dw7;
+};
+
+struct inter_packet_info {
+        void *data_buffer;
+        u32 payload;
+#define PTD_FIRE_NEXT           (1 << 0)
+#define PTD_URB_FINISHED        (1 << 1)
+        struct urb *urb;
+        struct isp1760_qh *qh;
+        struct isp1760_qtd *qtd;
+};
+
+
+typedef void (packet_enqueue)(struct usb_hcd *hcd, struct isp1760_qh *qh,
+                struct isp1760_qtd *qtd);
+
+#define isp1760_info(priv, fmt, args...) \
+        dev_info(priv_to_hcd(priv)->self.controller, fmt, ##args)
+
+#define isp1760_err(priv, fmt, args...) \
+        dev_err(priv_to_hcd(priv)->self.controller, fmt, ##args)
+
+/* chip memory management */
+struct memory_chunk {
+        unsigned int start;
+        unsigned int size;
+        unsigned int free;
+};
+
+/*
+ * 60kb divided in:
+ * - 32 blocks @ 256  bytes
+ * - 20 blocks @ 1024 bytes
+ * -  4 blocks @ 8192 bytes
+ */
+
+#define BLOCK_1_NUM 32
+#define BLOCK_2_NUM 20
+#define BLOCK_3_NUM 4
+
+#define BLOCK_1_SIZE 256
+#define BLOCK_2_SIZE 1024
+#define BLOCK_3_SIZE 8192
+#define BLOCKS (BLOCK_1_NUM + BLOCK_2_NUM + BLOCK_3_NUM)
+#define PAYLOAD_SIZE 0xf000
+
+/* I saw if some reloads if the pointer was negative */
+#define ISP1760_NULL_POINTER    (0x400)
+
+/* ATL */
+/* DW0 */
+#define PTD_VALID                       1
+#define PTD_LENGTH(x)                   (((u32) x) << 3)
+#define PTD_MAXPACKET(x)                (((u32) x) << 18)
+#define PTD_MULTI(x)                    (((u32) x) << 29)
+#define PTD_ENDPOINT(x)                 (((u32) x) << 31)
+/* DW1 */
+#define PTD_DEVICE_ADDR(x)              (((u32) x) << 3)
+#define PTD_PID_TOKEN(x)                (((u32) x) << 10)
+#define PTD_TRANS_BULK                  ((u32) 2 << 12)
+#define PTD_TRANS_INT                   ((u32) 3 << 12)
+#define PTD_TRANS_SPLIT                 ((u32) 1 << 14)
+#define PTD_SE_USB_LOSPEED              ((u32) 2 << 16)
+#define PTD_PORT_NUM(x)                 (((u32) x) << 18)
+#define PTD_HUB_NUM(x)                  (((u32) x) << 25)
+#define PTD_PING(x)                     (((u32) x) << 26)
+/* DW2 */
+#define PTD_RL_CNT(x)                   (((u32) x) << 25)
+#define PTD_DATA_START_ADDR(x)          (((u32) x) << 8)
+#define BASE_ADDR                       0x1000
+/* DW3 */
+#define PTD_CERR(x)                     (((u32) x) << 23)
+#define PTD_NAC_CNT(x)                  (((u32) x) << 19)
+#define PTD_ACTIVE                      ((u32) 1 << 31)
+#define PTD_DATA_TOGGLE(x)              (((u32) x) << 25)
+
+#define DW3_HALT_BIT                    (1 << 30)
+#define DW3_ERROR_BIT                   (1 << 28)
+#define DW3_QTD_ACTIVE                  (1 << 31)
+
+#define INT_UNDERRUN                    (1 << 2)
+#define INT_BABBLE                      (1 << 1)
+#define INT_EXACT                       (1 << 0)
+
+#define DW1_GET_PID(x)                  (((x) >> 10) & 0x3)
+#define PTD_XFERRED_LENGTH(x)           ((x) & 0x7fff)
+#define PTD_XFERRED_LENGTH_LO(x)        ((x) & 0x7ff)
+
+#define SETUP_PID       (2)
+#define IN_PID          (1)
+#define OUT_PID         (0)
+#define GET_QTD_TOKEN_TYPE(x)   ((x) & 0x3)
+
+#define DATA_TOGGLE             (1 << 31)
+#define GET_DATA_TOGGLE(x)      ((x) >> 31)
+
+/* Errata 1 */
+#define RL_COUNTER      (0)
+#define NAK_COUNTER     (0)
+#define ERR_COUNTER     (2)
+
+#define HC_ATL_PL_SIZE  (8192)
+
+#endif
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
new file mode 100644
index 000000000000..c9db3fe98726
--- /dev/null
+++ b/drivers/usb/host/isp1760-if.c
@@ -0,0 +1,298 @@
+/*
+ * Glue code for the ISP1760 driver and bus
+ * Currently there is support for
+ * - OpenFirmware
+ * - PCI
+ *
+ * (c) 2007 Sebastian Siewior <bigeasy@linutronix.de>
+ *
+ */
+
+#include <linux/usb.h>
+#include <linux/io.h>
+
+#include "../core/hcd.h"
+#include "isp1760-hcd.h"
+
+#ifdef CONFIG_USB_ISP1760_OF
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#endif
+
+#ifdef CONFIG_USB_ISP1760_PCI
+#include <linux/pci.h>
+#endif
+
+#ifdef CONFIG_USB_ISP1760_OF
+static int of_isp1760_probe(struct of_device *dev,
+                const struct of_device_id *match)
+{
+        struct usb_hcd *hcd;
+        struct device_node *dp = dev->node;
+        struct resource *res;
+        struct resource memory;
+        struct of_irq oirq;
+        int virq;
+        u64 res_len;
+        int ret;
+
+        ret = of_address_to_resource(dp, 0, &memory);
+        if (ret)
+                return -ENXIO;
+
+        res = request_mem_region(memory.start, memory.end - memory.start + 1,
+                        dev->dev.bus_id);
+        if (!res)
+                return -EBUSY;
+
+        res_len = memory.end - memory.start + 1;
+
+        if (of_irq_map_one(dp, 0, &oirq)) {
+                ret = -ENODEV;
+                goto release_reg;
+        }
+
+        virq = irq_create_of_mapping(oirq.controller, oirq.specifier,
+                        oirq.size);
+
+        hcd = isp1760_register(memory.start, res_len, virq,
+                IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev->dev.bus_id);
+        if (IS_ERR(hcd)) {
+                ret = PTR_ERR(hcd);
+                goto release_reg;
+        }
+
+        dev_set_drvdata(&dev->dev, hcd);
+        return ret;
+
+release_reg:
+        release_mem_region(memory.start, memory.end - memory.start + 1);
+        return ret;
+}
+
+static int of_isp1760_remove(struct of_device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&dev->dev);
+
+        dev_set_drvdata(&dev->dev, NULL);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        return 0;
+}
+
+static struct of_device_id of_isp1760_match[] = {
+        {
+                .compatible = "nxp,usb-isp1760",
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(of, of_isp1760_match);
+
+static struct of_platform_driver isp1760_of_driver = {
+        .name           = "nxp-isp1760",
+        .match_table    = of_isp1760_match,
+        .probe          = of_isp1760_probe,
+        .remove         = of_isp1760_remove,
+};
+#endif
+
+#ifdef CONFIG_USB_ISP1760_PCI
+static u32 nxp_pci_io_base;
+static u32 iolength;
+static u32 pci_mem_phy0;
+static u32 length;
+static u8 __iomem *chip_addr;
+static u8 __iomem *iobase;
+
+static int __devinit isp1761_pci_probe(struct pci_dev *dev,
+                const struct pci_device_id *id)
+{
+        u8 latency, limit;
+        __u32 reg_data;
+        int retry_count;
+        int length;
+        int status = 1;
+        struct usb_hcd *hcd;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        if (pci_enable_device(dev) < 0)
+                return -ENODEV;
+
+        if (!dev->irq)
+                return -ENODEV;
+
+        /* Grab the PLX PCI mem maped port start address we need  */
+        nxp_pci_io_base = pci_resource_start(dev, 0);
+        iolength = pci_resource_len(dev, 0);
+
+        if (!request_mem_region(nxp_pci_io_base, iolength, "ISP1761 IO MEM")) {
+                printk(KERN_ERR "request region #1\n");
+                return -EBUSY;
+        }
+
+        iobase = ioremap_nocache(nxp_pci_io_base, iolength);
+        if (!iobase) {
+                printk(KERN_ERR "ioremap #1\n");
+                release_mem_region(nxp_pci_io_base, iolength);
+                return -ENOMEM;
+        }
+        /* Grab the PLX PCI shared memory of the ISP 1761 we need  */
+        pci_mem_phy0 = pci_resource_start(dev, 3);
+        length = pci_resource_len(dev, 3);
+
+        if (length < 0xffff) {
+                printk(KERN_ERR "memory length for this resource is less than "
+                                "required\n");
+                release_mem_region(nxp_pci_io_base, iolength);
+                iounmap(iobase);
+                return  -ENOMEM;
+        }
+
+        if (!request_mem_region(pci_mem_phy0, length, "ISP-PCI")) {
+                printk(KERN_ERR "host controller already in use\n");
+                release_mem_region(nxp_pci_io_base, iolength);
+                iounmap(iobase);
+                return -EBUSY;
+        }
+
+        /* bad pci latencies can contribute to overruns */
+        pci_read_config_byte(dev, PCI_LATENCY_TIMER, &latency);
+        if (latency) {
+                pci_read_config_byte(dev, PCI_MAX_LAT, &limit);
+                if (limit && limit < latency)
+                        pci_write_config_byte(dev, PCI_LATENCY_TIMER, limit);
+        }
+
+        /* Try to check whether we can access Scratch Register of
+         * Host Controller or not. The initial PCI access is retried until
+         * local init for the PCI bridge is completed
+         */
+        retry_count = 20;
+        reg_data = 0;
+        while ((reg_data != 0xFACE) && retry_count) {
+                /*by default host is in 16bit mode, so
+                 * io operations at this stage must be 16 bit
+                 * */
+                writel(0xface, chip_addr + HC_SCRATCH_REG);
+                udelay(100);
+                reg_data = readl(chip_addr + HC_SCRATCH_REG);
+                retry_count--;
+        }
+
+        /* Host Controller presence is detected by writing to scratch register
+         * and reading back and checking the contents are same or not
+         */
+        if (reg_data != 0xFACE) {
+                err("scratch register mismatch %x", reg_data);
+                goto clean;
+        }
+
+        pci_set_master(dev);
+
+        status = readl(iobase + 0x68);
+        status |= 0x900;
+        writel(status, iobase + 0x68);
+
+        dev->dev.dma_mask = NULL;
+        hcd = isp1760_register(pci_mem_phy0, length, dev->irq,
+                IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev->dev.bus_id);
+        pci_set_drvdata(dev, hcd);
+        if (!hcd)
+                return 0;
+clean:
+        status = -ENODEV;
+        iounmap(iobase);
+        release_mem_region(pci_mem_phy0, length);
+        release_mem_region(nxp_pci_io_base, iolength);
+        return status;
+}
+static void isp1761_pci_remove(struct pci_dev *dev)
+{
+        struct usb_hcd *hcd;
+
+        hcd = pci_get_drvdata(dev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        pci_disable_device(dev);
+
+        iounmap(iobase);
+        iounmap(chip_addr);
+
+        release_mem_region(nxp_pci_io_base, iolength);
+        release_mem_region(pci_mem_phy0, length);
+}
+
+static void isp1761_pci_shutdown(struct pci_dev *dev)
+{
+        printk(KERN_ERR "ips1761_pci_shutdown\n");
+}
+
+static const struct pci_device_id isp1760_plx [] = { {
+        /* handle any USB 2.0 EHCI controller */
+        PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_OTHER << 8) | (0x06 << 16)), ~0),
+                .driver_data = 0,
+},
+{ /* end: all zeroes */ }
+};
+MODULE_DEVICE_TABLE(pci, isp1760_plx);
+
+static struct pci_driver isp1761_pci_driver = {
+        .name =         "isp1760",
+        .id_table =     isp1760_plx,
+        .probe =        isp1761_pci_probe,
+        .remove =       isp1761_pci_remove,
+        .shutdown =     isp1761_pci_shutdown,
+};
+#endif
+
+static int __init isp1760_init(void)
+{
+        int ret = -ENODEV;
+
+        init_kmem_once();
+
+#ifdef CONFIG_USB_ISP1760_OF
+        ret = of_register_platform_driver(&isp1760_of_driver);
+        if (ret) {
+                deinit_kmem_cache();
+                return ret;
+        }
+#endif
+#ifdef CONFIG_USB_ISP1760_PCI
+        ret = pci_register_driver(&isp1761_pci_driver);
+        if (ret)
+                goto unreg_of;
+#endif
+        return ret;
+
+#ifdef CONFIG_USB_ISP1760_PCI
+unreg_of:
+#endif
+#ifdef CONFIG_USB_ISP1760_OF
+        of_unregister_platform_driver(&isp1760_of_driver);
+#endif
+        deinit_kmem_cache();
+        return ret;
+}
+module_init(isp1760_init);
+
+static void __exit isp1760_exit(void)
+{
+#ifdef CONFIG_USB_ISP1760_OF
+        of_unregister_platform_driver(&isp1760_of_driver);
+#endif
+#ifdef CONFIG_USB_ISP1760_PCI
+        pci_unregister_driver(&isp1761_pci_driver);
+#endif
+        deinit_kmem_cache();
+}
+module_exit(isp1760_exit);
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index c96db1153dcf..e534f9de0f05 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -261,6 +261,7 @@ static const struct hc_driver ohci_at91_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 1b9abdba920b..f90fe0c7373f 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -288,6 +288,7 @@ static const struct hc_driver ohci_au1xxx_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-ep93xx.c b/drivers/usb/host/ohci-ep93xx.c
index 06aadfb0ec29..5adaf36e47d0 100644
--- a/drivers/usb/host/ohci-ep93xx.c
+++ b/drivers/usb/host/ohci-ep93xx.c
@@ -135,6 +135,7 @@ static struct hc_driver ohci_ep93xx_hc_driver = {
         .get_frame_number       = ohci_get_frame,
         .hub_status_data        = ohci_hub_status_data,
         .hub_control            = ohci_hub_control,
+        .hub_irq_enable         = ohci_rhsc_enable,
 #ifdef CONFIG_PM
         .bus_suspend            = ohci_bus_suspend,
         .bus_resume             = ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 33f1c1c32edf..a8160d65f32b 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1054,7 +1054,7 @@ MODULE_LICENSE ("GPL");
 
 #ifdef CONFIG_MFD_SM501
 #include "ohci-sm501.c"
-#define PLATFORM_DRIVER         ohci_hcd_sm501_driver
+#define SM501_OHCI_DRIVER       ohci_hcd_sm501_driver
 #endif
 
 #if     !defined(PCI_DRIVER) &&         \
@@ -1062,6 +1062,7 @@ MODULE_LICENSE ("GPL");
         !defined(OF_PLATFORM_DRIVER) && \
         !defined(SA1111_DRIVER) &&      \
         !defined(PS3_SYSTEM_BUS_DRIVER) && \
+        !defined(SM501_OHCI_DRIVER) && \
         !defined(SSB_OHCI_DRIVER)
 #error "missing bus glue for ohci-hcd"
 #endif
@@ -1121,9 +1122,18 @@ static int __init ohci_hcd_mod_init(void)
                 goto error_ssb;
 #endif
 
+#ifdef SM501_OHCI_DRIVER
+        retval = platform_driver_register(&SM501_OHCI_DRIVER);
+        if (retval < 0)
+                goto error_sm501;
+#endif
+
         return retval;
 
         /* Error path */
+#ifdef SM501_OHCI_DRIVER
+ error_sm501:
+#endif
 #ifdef SSB_OHCI_DRIVER
  error_ssb:
 #endif
@@ -1159,6 +1169,9 @@ module_init(ohci_hcd_mod_init);
 
 static void __exit ohci_hcd_mod_exit(void)
 {
+#ifdef SM501_OHCI_DRIVER
+        platform_driver_unregister(&SM501_OHCI_DRIVER);
+#endif
 #ifdef SSB_OHCI_DRIVER
         ssb_driver_unregister(&SSB_OHCI_DRIVER);
 #endif
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 17dc2eccda83..b56739221d11 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -36,6 +36,18 @@
 
 /*-------------------------------------------------------------------------*/
 
+/* hcd->hub_irq_enable() */
+static void ohci_rhsc_enable (struct usb_hcd *hcd)
+{
+        struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
+
+        spin_lock_irq(&ohci->lock);
+        if (!ohci->autostop)
+                del_timer(&hcd->rh_timer);      /* Prevent next poll */
+        ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable);
+        spin_unlock_irq(&ohci->lock);
+}
+
 #define OHCI_SCHED_ENABLES \
         (OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
 
@@ -362,28 +374,18 @@ static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
                 int any_connected)
 {
         int     poll_rh = 1;
-        int     rhsc;
 
-        rhsc = ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC;
         switch (ohci->hc_control & OHCI_CTRL_HCFS) {
 
         case OHCI_USB_OPER:
-                /* If no status changes are pending, enable status-change
-                 * interrupts.
-                 */
-                if (!rhsc && !changed) {
-                        rhsc = OHCI_INTR_RHSC;
-                        ohci_writel(ohci, rhsc, &ohci->regs->intrenable);
-                }
-
-                /* Keep on polling until we know a device is connected
-                 * and RHSC is enabled, or until we autostop.
-                 */
+                /* keep on polling until we know a device is connected
+                 * and RHSC is enabled */
                 if (!ohci->autostop) {
                         if (any_connected ||
                                         !device_may_wakeup(&ohci_to_hcd(ohci)
                                                 ->self.root_hub->dev)) {
-                                if (rhsc)
+                                if (ohci_readl(ohci, &ohci->regs->intrenable) &
+                                                OHCI_INTR_RHSC)
                                         poll_rh = 0;
                         } else {
                                 ohci->autostop = 1;
@@ -396,13 +398,12 @@ static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
                                 ohci->autostop = 0;
                                 ohci->next_statechange = jiffies +
                                                 STATECHANGE_DELAY;
-                        } else if (rhsc && time_after_eq(jiffies,
+                        } else if (time_after_eq(jiffies,
                                                 ohci->next_statechange)
                                         && !ohci->ed_rm_list
                                         && !(ohci->hc_control &
                                                 OHCI_SCHED_ENABLES)) {
                                 ohci_rh_suspend(ohci, 1);
-                                poll_rh = 0;
                         }
                 }
                 break;
@@ -416,12 +417,6 @@ static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
                         else
                                 usb_hcd_resume_root_hub(ohci_to_hcd(ohci));
                 } else {
-                        if (!rhsc && (ohci->autostop ||
-                                        ohci_to_hcd(ohci)->self.root_hub->
-                                                do_remote_wakeup))
-                                ohci_writel(ohci, OHCI_INTR_RHSC,
-                                                &ohci->regs->intrenable);
-
                         /* everything is idle, no need for polling */
                         poll_rh = 0;
                 }
@@ -443,16 +438,12 @@ static inline int ohci_rh_resume(struct ohci_hcd *ohci)
 static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
                 int any_connected)
 {
-        /* If RHSC is enabled, don't poll */
-        if (ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC)
-                return 0;
+        int     poll_rh = 1;
 
-        /* If no status changes are pending, enable status-change interrupts */
-        if (!changed) {
-                ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable);
-                return 0;
-        }
-        return 1;
+        /* keep on polling until RHSC is enabled */
+        if (ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC)
+                poll_rh = 0;
+        return poll_rh;
 }
 
 #endif  /* CONFIG_PM */
@@ -613,7 +604,7 @@ static void start_hnp(struct ohci_hcd *ohci);
 static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port)
 {
         __hc32 __iomem *portstat = &ohci->regs->roothub.portstatus [port];
-        u32     temp;
+        u32     temp = 0;
         u16     now = ohci_readl(ohci, &ohci->regs->fmnumber);
         u16     reset_done = now + PORT_RESET_MSEC;
         int     limit_1 = DIV_ROUND_UP(PORT_RESET_MSEC, PORT_RESET_HW_MSEC);
diff --git a/drivers/usb/host/ohci-lh7a404.c b/drivers/usb/host/ohci-lh7a404.c
index 96d14fa1d833..13c12ed22252 100644
--- a/drivers/usb/host/ohci-lh7a404.c
+++ b/drivers/usb/host/ohci-lh7a404.c
@@ -193,6 +193,7 @@ static const struct hc_driver ohci_lh7a404_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index 6859fb5f1d6f..3a7c24c03671 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -466,6 +466,7 @@ static const struct hc_driver ohci_omap_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index 3bf175d95a23..4696cc912e16 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -327,6 +327,7 @@ static const struct hc_driver ohci_pci_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-pnx4008.c b/drivers/usb/host/ohci-pnx4008.c
index 664f07ee8732..28b458f20cc3 100644
--- a/drivers/usb/host/ohci-pnx4008.c
+++ b/drivers/usb/host/ohci-pnx4008.c
@@ -280,6 +280,7 @@ static const struct hc_driver ohci_pnx4008_hc_driver = {
          */
         .hub_status_data = ohci_hub_status_data,
         .hub_control = ohci_hub_control,
+        .hub_irq_enable = ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend = ohci_bus_suspend,
         .bus_resume = ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-pnx8550.c b/drivers/usb/host/ohci-pnx8550.c
index 28467e288a93..605d59cba28e 100644
--- a/drivers/usb/host/ohci-pnx8550.c
+++ b/drivers/usb/host/ohci-pnx8550.c
@@ -201,6 +201,7 @@ static const struct hc_driver ohci_pnx8550_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index 50e55db13636..a67252791223 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -72,6 +72,7 @@ static const struct hc_driver ohci_ppc_of_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-ppc-soc.c b/drivers/usb/host/ohci-ppc-soc.c
index cd3398b675b2..523c30125577 100644
--- a/drivers/usb/host/ohci-ppc-soc.c
+++ b/drivers/usb/host/ohci-ppc-soc.c
@@ -172,6 +172,7 @@ static const struct hc_driver ohci_ppc_soc_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-ps3.c b/drivers/usb/host/ohci-ps3.c
index bfdeb0d22d05..c1935ae537f8 100644
--- a/drivers/usb/host/ohci-ps3.c
+++ b/drivers/usb/host/ohci-ps3.c
@@ -68,6 +68,7 @@ static const struct hc_driver ps3_ohci_hc_driver = {
         .get_frame_number       = ohci_get_frame,
         .hub_status_data        = ohci_hub_status_data,
         .hub_control            = ohci_hub_control,
+        .hub_irq_enable         = ohci_rhsc_enable,
         .start_port_reset       = ohci_start_port_reset,
 #if defined(CONFIG_PM)
         .bus_suspend            = ohci_bus_suspend,
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 70b0d4b459e7..d4ee27d92be8 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -298,6 +298,7 @@ static const struct hc_driver ohci_pxa27x_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 9c9f3b59186f..9b547407c934 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -952,6 +952,7 @@ rescan_this:
                         struct urb      *urb;
                         urb_priv_t      *urb_priv;
                         __hc32          savebits;
+                        u32             tdINFO;
 
                         td = list_entry (entry, struct td, td_list);
                         urb = td->urb;
@@ -966,6 +967,17 @@ rescan_this:
                         savebits = *prev & ~cpu_to_hc32 (ohci, TD_MASK);
                         *prev = td->hwNextTD | savebits;
 
+                        /* If this was unlinked, the TD may not have been
+                         * retired ... so manually save the data toggle.
+                         * The controller ignores the value we save for
+                         * control and ISO endpoints.
+                         */
+                        tdINFO = hc32_to_cpup(ohci, &td->hwINFO);
+                        if ((tdINFO & TD_T) == TD_T_DATA0)
+                                ed->hwHeadP &= ~cpu_to_hc32(ohci, ED_C);
+                        else if ((tdINFO & TD_T) == TD_T_DATA1)
+                                ed->hwHeadP |= cpu_to_hc32(ohci, ED_C);
+
                         /* HC may have partly processed this TD */
                         td_done (ohci, urb, td);
                         urb_priv->td_cnt++;
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index a73d2ff322e2..ead4772f0f27 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -466,6 +466,7 @@ static const struct hc_driver ohci_s3c2410_hc_driver = {
          */
         .hub_status_data =      ohci_s3c2410_hub_status_data,
         .hub_control =          ohci_s3c2410_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
index 99438c65981b..0f48f2d99226 100644
--- a/drivers/usb/host/ohci-sa1111.c
+++ b/drivers/usb/host/ohci-sa1111.c
@@ -231,6 +231,7 @@ static const struct hc_driver ohci_sa1111_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-sh.c b/drivers/usb/host/ohci-sh.c
index 60f03cc7ec4f..e7ee607278fe 100644
--- a/drivers/usb/host/ohci-sh.c
+++ b/drivers/usb/host/ohci-sh.c
@@ -68,6 +68,7 @@ static const struct hc_driver ohci_sh_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index 77204f001b9a..e610698c6b60 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -75,6 +75,7 @@ static const struct hc_driver ohci_sm501_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+        .hub_irq_enable =       ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend =          ohci_bus_suspend,
         .bus_resume =           ohci_bus_resume,
@@ -90,7 +91,7 @@ static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
         struct device *dev = &pdev->dev;
         struct resource *res, *mem;
         int retval, irq;
-        struct usb_hcd *hcd = 0;
+        struct usb_hcd *hcd = NULL;
 
         irq = retval = platform_get_irq(pdev, 0);
         if (retval < 0)
diff --git a/drivers/usb/host/ohci-ssb.c b/drivers/usb/host/ohci-ssb.c
index c4265caec780..7275186db315 100644
--- a/drivers/usb/host/ohci-ssb.c
+++ b/drivers/usb/host/ohci-ssb.c
@@ -81,6 +81,7 @@ static const struct hc_driver ssb_ohci_hc_driver = {
 
         .hub_status_data        = ohci_hub_status_data,
         .hub_control            = ohci_hub_control,
+        .hub_irq_enable         = ohci_rhsc_enable,
 #ifdef  CONFIG_PM
         .bus_suspend            = ohci_bus_suspend,
         .bus_resume             = ohci_bus_resume,
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index f29307405bb3..9b6323f768b2 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -2934,6 +2934,16 @@ static int u132_start_port_reset(struct usb_hcd *hcd, unsigned port_num)
                 return 0;
 }
 
+static void u132_hub_irq_enable(struct usb_hcd *hcd)
+{
+        struct u132 *u132 = hcd_to_u132(hcd);
+        if (u132->going > 1) {
+                dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
+                        , u132->going);
+        } else if (u132->going > 0)
+                dev_err(&u132->platform_dev->dev, "device is being removed\n");
+}
+
 
 #ifdef CONFIG_PM
 static int u132_bus_suspend(struct usb_hcd *hcd)
@@ -2985,6 +2995,7 @@ static struct hc_driver u132_hc_driver = {
         .bus_suspend = u132_bus_suspend,
         .bus_resume = u132_bus_resume,
         .start_port_reset = u132_start_port_reset,
+        .hub_irq_enable = u132_hub_irq_enable,
 };
 
 /*
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index d3e0d8aa3980..3a7bfe7a8874 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -234,7 +234,7 @@ static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
         return 0;
 }
 
-static int remote_wakeup_is_broken(struct uhci_hcd *uhci)
+static int global_suspend_mode_is_broken(struct uhci_hcd *uhci)
 {
         int port;
         const char *sys_info;
@@ -261,27 +261,60 @@ __releases(uhci->lock)
 __acquires(uhci->lock)
 {
         int auto_stop;
-        int int_enable, egsm_enable;
+        int int_enable, egsm_enable, wakeup_enable;
         struct usb_device *rhdev = uhci_to_hcd(uhci)->self.root_hub;
 
         auto_stop = (new_state == UHCI_RH_AUTO_STOPPED);
         dev_dbg(&rhdev->dev, "%s%s\n", __func__,
                         (auto_stop ? " (auto-stop)" : ""));
 
-        /* Enable resume-detect interrupts if they work.
-         * Then enter Global Suspend mode if _it_ works, still configured.
+        /* Start off by assuming Resume-Detect interrupts and EGSM work
+         * and that remote wakeups should be enabled.
          */
         egsm_enable = USBCMD_EGSM;
-        uhci->working_RD = 1;
+        uhci->RD_enable = 1;
         int_enable = USBINTR_RESUME;
-        if (remote_wakeup_is_broken(uhci))
-                egsm_enable = 0;
-        if (resume_detect_interrupts_are_broken(uhci) || !egsm_enable ||
+        wakeup_enable = 1;
+
+        /* In auto-stop mode wakeups must always be detected, but
+         * Resume-Detect interrupts may be prohibited.  (In the absence
+         * of CONFIG_PM, they are always disallowed.)
+         */
+        if (auto_stop) {
+                if (!device_may_wakeup(&rhdev->dev))
+                        int_enable = 0;
+
+        /* In bus-suspend mode wakeups may be disabled, but if they are
+         * allowed then so are Resume-Detect interrupts.
+         */
+        } else {
 #ifdef CONFIG_PM
-                        (!auto_stop && !rhdev->do_remote_wakeup) ||
+                if (!rhdev->do_remote_wakeup)
+                        wakeup_enable = 0;
 #endif
-                        (auto_stop && !device_may_wakeup(&rhdev->dev)))
-                uhci->working_RD = int_enable = 0;
+        }
+
+        /* EGSM causes the root hub to echo a 'K' signal (resume) out any
+         * port which requests a remote wakeup.  According to the USB spec,
+         * every hub is supposed to do this.  But if we are ignoring
+         * remote-wakeup requests anyway then there's no point to it.
+         * We also shouldn't enable EGSM if it's broken.
+         */
+        if (!wakeup_enable || global_suspend_mode_is_broken(uhci))
+                egsm_enable = 0;
+
+        /* If we're ignoring wakeup events then there's no reason to
+         * enable Resume-Detect interrupts.  We also shouldn't enable
+         * them if they are broken or disallowed.
+         *
+         * This logic may lead us to enabling RD but not EGSM.  The UHCI
+         * spec foolishly says that RD works only when EGSM is on, but
+         * there's no harm in enabling it anyway -- perhaps some chips
+         * will implement it!
+         */
+        if (!wakeup_enable || resume_detect_interrupts_are_broken(uhci) ||
+                        !int_enable)
+                uhci->RD_enable = int_enable = 0;
 
         outw(int_enable, uhci->io_addr + USBINTR);
         outw(egsm_enable | USBCMD_CF, uhci->io_addr + USBCMD);
@@ -308,7 +341,11 @@ __acquires(uhci->lock)
 
         uhci->rh_state = new_state;
         uhci->is_stopped = UHCI_IS_STOPPED;
-        uhci_to_hcd(uhci)->poll_rh = !int_enable;
+
+        /* If interrupts don't work and remote wakeup is enabled then
+         * the suspended root hub needs to be polled.
+         */
+        uhci_to_hcd(uhci)->poll_rh = (!int_enable && wakeup_enable);
 
         uhci_scan_schedule(uhci);
         uhci_fsbr_off(uhci);
@@ -344,9 +381,12 @@ __acquires(uhci->lock)
          * for 20 ms.
          */
         if (uhci->rh_state == UHCI_RH_SUSPENDED) {
+                unsigned egsm;
+
+                /* Keep EGSM on if it was set before */
+                egsm = inw(uhci->io_addr + USBCMD) & USBCMD_EGSM;
                 uhci->rh_state = UHCI_RH_RESUMING;
-                outw(USBCMD_FGR | USBCMD_EGSM | USBCMD_CF,
-                                uhci->io_addr + USBCMD);
+                outw(USBCMD_FGR | USBCMD_CF | egsm, uhci->io_addr + USBCMD);
                 spin_unlock_irq(&uhci->lock);
                 msleep(20);
                 spin_lock_irq(&uhci->lock);
@@ -801,8 +841,10 @@ static int uhci_pci_resume(struct usb_hcd *hcd)
 
         spin_unlock_irq(&uhci->lock);
 
-        if (!uhci->working_RD) {
-                /* Suspended root hub needs to be polled */
+        /* If interrupts don't work and remote wakeup is enabled then
+         * the suspended root hub needs to be polled.
+         */
+        if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup) {
                 hcd->poll_rh = 1;
                 usb_hcd_poll_rh_status(hcd);
         }
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index 340d6ed3e6e9..7d01c5677f92 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -400,8 +400,9 @@ struct uhci_hcd {
         unsigned int scan_in_progress:1;        /* Schedule scan is running */
         unsigned int need_rescan:1;             /* Redo the schedule scan */
         unsigned int dead:1;                    /* Controller has died */
-        unsigned int working_RD:1;              /* Suspended root hub doesn't
-                                                   need to be polled */
+        unsigned int RD_enable:1;               /* Suspended root hub with
+                                                   Resume-Detect interrupts
+                                                   enabled */
         unsigned int is_initialized:1;          /* Data structure is usable */
         unsigned int fsbr_is_on:1;              /* FSBR is turned on */
         unsigned int fsbr_is_wanted:1;          /* Does any URB want FSBR? */
diff --git a/drivers/usb/misc/Kconfig b/drivers/usb/misc/Kconfig
index a53db1d4e07a..001789c9a11a 100644
--- a/drivers/usb/misc/Kconfig
+++ b/drivers/usb/misc/Kconfig
@@ -269,3 +269,15 @@ config USB_TEST
           See <http://www.linux-usb.org/usbtest/> for more information,
           including sample test device firmware and "how to use it".
 
+config USB_ISIGHTFW
+        tristate "iSight firmware loading support"
+        depends on USB
+        select FW_LOADER
+        help
+          This driver loads firmware for USB Apple iSight cameras, allowing
+          them to be driven by the USB video class driver available at
+          http://linux-uvc.berlios.de
+
+          The firmware for this driver must be extracted from the MacOS
+          driver beforehand. Tools for doing so are available at
+          http://bersace03.free.fr
diff --git a/drivers/usb/misc/Makefile b/drivers/usb/misc/Makefile
index b68e6b774f1a..aba091cb5ec0 100644
--- a/drivers/usb/misc/Makefile
+++ b/drivers/usb/misc/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_USB_EMI62)		+= emi62.o
 obj-$(CONFIG_USB_FTDI_ELAN)     += ftdi-elan.o
 obj-$(CONFIG_USB_IDMOUSE)       += idmouse.o
 obj-$(CONFIG_USB_IOWARRIOR)     += iowarrior.o
+obj-$(CONFIG_USB_ISIGHTFW)      += isight_firmware.o
 obj-$(CONFIG_USB_LCD)           += usblcd.o
 obj-$(CONFIG_USB_LD)            += ldusb.o
 obj-$(CONFIG_USB_LED)           += usbled.o
diff --git a/drivers/usb/misc/isight_firmware.c b/drivers/usb/misc/isight_firmware.c
new file mode 100644
index 000000000000..9f30aa1f8a5d
--- /dev/null
+++ b/drivers/usb/misc/isight_firmware.c
@@ -0,0 +1,140 @@
+/*
+ * Driver for loading USB isight firmware
+ *
+ * Copyright (C) 2008 Matthew Garrett <mjg@redhat.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.
+ *
+ * The USB isight cameras in recent Apples are roughly compatible with the USB
+ * video class specification, and can be driven by uvcvideo. However, they
+ * need firmware to be loaded beforehand. After firmware loading, the device
+ * detaches from the USB bus and reattaches with a new device ID. It can then
+ * be claimed by the uvc driver.
+ *
+ * The firmware is non-free and must be extracted by the user. Tools to do this
+ * are available at http://bersace03.free.fr/ift/
+ *
+ * The isight firmware loading was reverse engineered by Johannes Berg
+ * <johannes@sipsolutions.de>, and this driver is based on code by Ronald
+ * Bultje <rbultje@ronald.bitfreak.net>
+ */
+
+#include <linux/usb.h>
+#include <linux/firmware.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+
+static struct usb_device_id id_table[] = {
+        {USB_DEVICE(0x05ac, 0x8300)},
+        {},
+};
+
+MODULE_DEVICE_TABLE(usb, id_table);
+
+static int isight_firmware_load(struct usb_interface *intf,
+                                const struct usb_device_id *id)
+{
+        struct usb_device *dev = interface_to_usbdev(intf);
+        int llen, len, req, ret = 0;
+        const struct firmware *firmware;
+        unsigned char *buf = kmalloc(50, GFP_KERNEL);
+        unsigned char data[4];
+        u8 *ptr;
+
+        if (!buf)
+                return -ENOMEM;
+
+        if (request_firmware(&firmware, "isight.fw", &dev->dev) != 0) {
+                printk(KERN_ERR "Unable to load isight firmware\n");
+                return -ENODEV;
+        }
+
+        ptr = firmware->data;
+
+        if (usb_control_msg
+            (dev, usb_sndctrlpipe(dev, 0), 0xa0, 0x40, 0xe600, 0, "\1", 1,
+             300) != 1) {
+                printk(KERN_ERR
+                       "Failed to initialise isight firmware loader\n");
+                ret = -ENODEV;
+                goto out;
+        }
+
+        while (ptr+4 <= firmware->data+firmware->size) {
+                memcpy(data, ptr, 4);
+                len = (data[0] << 8 | data[1]);
+                req = (data[2] << 8 | data[3]);
+                ptr += 4;
+
+                if (len == 0x8001)
+                        break;  /* success */
+                else if (len == 0)
+                        continue;
+
+                for (; len > 0; req += 50) {
+                        llen = min(len, 50);
+                        len -= llen;
+                        if (ptr+llen > firmware->data+firmware->size) {
+                                printk(KERN_ERR
+                                       "Malformed isight firmware");
+                                ret = -ENODEV;
+                                goto out;
+                        }
+                        memcpy(buf, ptr, llen);
+
+                        ptr += llen;
+
+                        if (usb_control_msg
+                            (dev, usb_sndctrlpipe(dev, 0), 0xa0, 0x40, req, 0,
+                             buf, llen, 300) != llen) {
+                                printk(KERN_ERR
+                                       "Failed to load isight firmware\n");
+                                kfree(buf);
+                                ret = -ENODEV;
+                                goto out;
+                        }
+
+                }
+        }
+
+        if (usb_control_msg
+            (dev, usb_sndctrlpipe(dev, 0), 0xa0, 0x40, 0xe600, 0, "\0", 1,
+             300) != 1) {
+                printk(KERN_ERR "isight firmware loading completion failed\n");
+                ret = -ENODEV;
+        }
+
+out:
+        kfree(buf);
+        release_firmware(firmware);
+        return ret;
+}
+
+static void isight_firmware_disconnect(struct usb_interface *intf)
+{
+}
+
+static struct usb_driver isight_firmware_driver = {
+        .name = "isight_firmware",
+        .probe = isight_firmware_load,
+        .disconnect = isight_firmware_disconnect,
+        .id_table = id_table,
+};
+
+static int __init isight_firmware_init(void)
+{
+        return usb_register(&isight_firmware_driver);
+}
+
+static void __exit isight_firmware_exit(void)
+{
+        usb_deregister(&isight_firmware_driver);
+}
+
+module_init(isight_firmware_init);
+module_exit(isight_firmware_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index 11580e81e2c6..189a9db03509 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -63,9 +63,6 @@
 #define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
 #define USB_DEVICE_ID_VERNIER_LCSPEC    0x0006
 
-#define USB_VENDOR_ID_MICROCHIP         0x04d8
-#define USB_DEVICE_ID_PICDEM            0x000c
-
 #ifdef CONFIG_USB_DYNAMIC_MINORS
 #define USB_LD_MINOR_BASE       0
 #else
@@ -92,7 +89,6 @@ static struct usb_device_id ld_usb_table [] = {
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
-        { USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICDEM) },
         { USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },
         { }                                     /* Terminating entry */
 };
@@ -148,7 +144,7 @@ MODULE_PARM_DESC(min_interrupt_out_interval, "Minimum interrupt out interval in
 
 /* Structure to hold all of our device specific stuff */
 struct ld_usb {
-        struct semaphore        sem;            /* locks this structure */
+        struct mutex            mutex;          /* locks this structure */
         struct usb_interface*   intf;           /* save off the usb interface pointer */
 
         int                     open_count;     /* number of times this port has been opened */
@@ -319,7 +315,7 @@ static int ld_usb_open(struct inode *inode, struct file *file)
                 return -ENODEV;
 
         /* lock this device */
-        if (down_interruptible(&dev->sem))
+        if (mutex_lock_interruptible(&dev->mutex))
                 return -ERESTARTSYS;
 
         /* allow opening only once */
@@ -358,7 +354,7 @@ static int ld_usb_open(struct inode *inode, struct file *file)
         file->private_data = dev;
 
 unlock_exit:
-        up(&dev->sem);
+        mutex_unlock(&dev->mutex);
 
         return retval;
 }
@@ -378,7 +374,7 @@ static int ld_usb_release(struct inode *inode, struct file *file)
                 goto exit;
         }
 
-        if (down_interruptible(&dev->sem)) {
+        if (mutex_lock_interruptible(&dev->mutex)) {
                 retval = -ERESTARTSYS;
                 goto exit;
         }
@@ -389,7 +385,7 @@ static int ld_usb_release(struct inode *inode, struct file *file)
         }
         if (dev->intf == NULL) {
                 /* the device was unplugged before the file was released */
-                up(&dev->sem);
+                mutex_unlock(&dev->mutex);
                 /* unlock here as ld_usb_delete frees dev */
                 ld_usb_delete(dev);
                 goto exit;
@@ -402,7 +398,7 @@ static int ld_usb_release(struct inode *inode, struct file *file)
         dev->open_count = 0;
 
 unlock_exit:
-        up(&dev->sem);
+        mutex_unlock(&dev->mutex);
 
 exit:
         return retval;
@@ -448,7 +444,7 @@ static ssize_t ld_usb_read(struct file *file, char __user *buffer, size_t count,
                 goto exit;
 
         /* lock this object */
-        if (down_interruptible(&dev->sem)) {
+        if (mutex_lock_interruptible(&dev->mutex)) {
                 retval = -ERESTARTSYS;
                 goto exit;
         }
@@ -505,7 +501,7 @@ static ssize_t ld_usb_read(struct file *file, char __user *buffer, size_t count,
 
 unlock_exit:
         /* unlock the device */
-        up(&dev->sem);
+        mutex_unlock(&dev->mutex);
 
 exit:
         return retval;
@@ -528,7 +524,7 @@ static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
                 goto exit;
 
         /* lock this object */
-        if (down_interruptible(&dev->sem)) {
+        if (mutex_lock_interruptible(&dev->mutex)) {
                 retval = -ERESTARTSYS;
                 goto exit;
         }
@@ -602,7 +598,7 @@ static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
 
 unlock_exit:
         /* unlock the device */
-        up(&dev->sem);
+        mutex_unlock(&dev->mutex);
 
 exit:
         return retval;
@@ -651,7 +647,7 @@ static int ld_usb_probe(struct usb_interface *intf, const struct usb_device_id *
                 dev_err(&intf->dev, "Out of memory\n");
                 goto exit;
         }
-        init_MUTEX(&dev->sem);
+        mutex_init(&dev->mutex);
         spin_lock_init(&dev->rbsl);
         dev->intf = intf;
         init_waitqueue_head(&dev->read_wait);
@@ -765,15 +761,15 @@ static void ld_usb_disconnect(struct usb_interface *intf)
         /* give back our minor */
         usb_deregister_dev(intf, &ld_usb_class);
 
-        down(&dev->sem);
+        mutex_lock(&dev->mutex);
 
         /* if the device is not opened, then we clean up right now */
         if (!dev->open_count) {
-                up(&dev->sem);
+                mutex_unlock(&dev->mutex);
                 ld_usb_delete(dev);
         } else {
                 dev->intf = NULL;
-                up(&dev->sem);
+                mutex_unlock(&dev->mutex);
         }
 
         dev_info(&intf->dev, "LD USB Device #%d now disconnected\n",
diff --git a/drivers/usb/misc/phidgetkit.c b/drivers/usb/misc/phidgetkit.c
index 24230c638b8e..4cfa25b0f44e 100644
--- a/drivers/usb/misc/phidgetkit.c
+++ b/drivers/usb/misc/phidgetkit.c
@@ -595,14 +595,14 @@ static int interfacekit_probe(struct usb_interface *intf, const struct usb_devic
         } while(value);
         kit->dev_no = bit;
 
-        kit->dev = device_create(phidget_class, &kit->udev->dev, 0,
-                        "interfacekit%d", kit->dev_no);
+        kit->dev = device_create_drvdata(phidget_class, &kit->udev->dev,
+                                        MKDEV(0, 0), kit,
+                                        "interfacekit%d", kit->dev_no);
         if (IS_ERR(kit->dev)) {
                 rc = PTR_ERR(kit->dev);
                 kit->dev = NULL;
                 goto out;
         }
-        dev_set_drvdata(kit->dev, kit);
 
         if (usb_submit_urb(kit->irq, GFP_KERNEL)) {
                 rc = -EIO;
diff --git a/drivers/usb/misc/phidgetmotorcontrol.c b/drivers/usb/misc/phidgetmotorcontrol.c
index f0113c17cc5a..9b4696f21b22 100644
--- a/drivers/usb/misc/phidgetmotorcontrol.c
+++ b/drivers/usb/misc/phidgetmotorcontrol.c
@@ -365,16 +365,15 @@ static int motorcontrol_probe(struct usb_interface *intf, const struct usb_devic
         } while(value);
         mc->dev_no = bit;
 
-        mc->dev = device_create(phidget_class, &mc->udev->dev, 0,
-                                "motorcontrol%d", mc->dev_no);
+        mc->dev = device_create_drvdata(phidget_class, &mc->udev->dev,
+                                        MKDEV(0, 0), mc,
+                                        "motorcontrol%d", mc->dev_no);
         if (IS_ERR(mc->dev)) {
                 rc = PTR_ERR(mc->dev);
                 mc->dev = NULL;
                 goto out;
         }
 
-        dev_set_drvdata(mc->dev, mc);
-
         if (usb_submit_urb(mc->irq, GFP_KERNEL)) {
                 rc = -EIO;
                 goto out;
diff --git a/drivers/usb/misc/phidgetservo.c b/drivers/usb/misc/phidgetservo.c
index 7d590c09434a..1ca7ddb41d4d 100644
--- a/drivers/usb/misc/phidgetservo.c
+++ b/drivers/usb/misc/phidgetservo.c
@@ -275,14 +275,14 @@ servo_probe(struct usb_interface *interface, const struct usb_device_id *id)
         } while (value);
         dev->dev_no = bit;
 
-        dev->dev = device_create(phidget_class, &dev->udev->dev, 0,
-                                 "servo%d", dev->dev_no);
+        dev->dev = device_create_drvdata(phidget_class, &dev->udev->dev,
+                                         MKDEV(0, 0), dev,
+                                         "servo%d", dev->dev_no);
         if (IS_ERR(dev->dev)) {
                 rc = PTR_ERR(dev->dev);
                 dev->dev = NULL;
                 goto out;
         }
-        dev_set_drvdata(dev->dev, dev);
 
         servo_count = dev->type & SERVO_COUNT_QUAD ? 4 : 1;
 
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index cb7fa0eaf3ae..33182f4c2267 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -3264,8 +3264,6 @@ static void sisusb_disconnect(struct usb_interface *intf)
 
         /* decrement our usage count */
         kref_put(&sisusb->kref, sisusb_delete);
-
-        dev_info(&sisusb->sisusb_dev->dev, "Disconnected\n");
 }
 
 static struct usb_device_id sisusb_table [] = {
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index a51983854ca0..054dedd28127 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -79,30 +79,10 @@ static struct usb_device *testdev_to_usbdev (struct usbtest_dev *test)
 /* set up all urbs so they can be used with either bulk or interrupt */
 #define INTERRUPT_RATE          1       /* msec/transfer */
 
-#define xprintk(tdev,level,fmt,args...) \
-        dev_printk(level ,  &(tdev)->intf->dev ,  fmt ,  ## args)
-
-#ifdef DEBUG
-#define DBG(dev,fmt,args...) \
-        xprintk(dev , KERN_DEBUG , fmt , ## args)
-#else
-#define DBG(dev,fmt,args...) \
-        do { } while (0)
-#endif /* DEBUG */
-
-#ifdef VERBOSE
-#define VDBG DBG
-#else
-#define VDBG(dev,fmt,args...) \
-        do { } while (0)
-#endif  /* VERBOSE */
-
-#define ERROR(dev,fmt,args...) \
-        xprintk(dev , KERN_ERR , fmt , ## args)
-#define WARN(dev,fmt,args...) \
-        xprintk(dev , KERN_WARNING , fmt , ## args)
-#define INFO(dev,fmt,args...) \
-        xprintk(dev , KERN_INFO , fmt , ## args)
+#define ERROR(tdev, fmt, args...) \
+        dev_err(&(tdev)->intf->dev , fmt , ## args)
+#define WARN(tdev, fmt, args...) \
+        dev_warn(&(tdev)->intf->dev , fmt , ## args)
 
 /*-------------------------------------------------------------------------*/
 
@@ -236,7 +216,7 @@ static struct urb *simple_alloc_urb (
 
 static unsigned pattern = 0;
 module_param (pattern, uint, S_IRUGO);
-// MODULE_PARM_DESC (pattern, "i/o pattern (0 == zeroes)");
+MODULE_PARM_DESC(pattern, "i/o pattern (0 == zeroes)");
 
 static inline void simple_fill_buf (struct urb *urb)
 {
@@ -257,7 +237,7 @@ static inline void simple_fill_buf (struct urb *urb)
         }
 }
 
-static inline int simple_check_buf (struct urb *urb)
+static inline int simple_check_buf(struct usbtest_dev *tdev, struct urb *urb)
 {
         unsigned        i;
         u8              expected;
@@ -285,7 +265,7 @@ static inline int simple_check_buf (struct urb *urb)
                 }
                 if (*buf == expected)
                         continue;
-                dbg ("buf[%d] = %d (not %d)", i, *buf, expected);
+                ERROR(tdev, "buf[%d] = %d (not %d)\n", i, *buf, expected);
                 return -EINVAL;
         }
         return 0;
@@ -299,6 +279,7 @@ static void simple_free_urb (struct urb *urb)
 }
 
 static int simple_io (
+        struct usbtest_dev      *tdev,
         struct urb              *urb,
         int                     iterations,
         int                     vary,
@@ -324,7 +305,7 @@ static int simple_io (
                 retval = urb->status;
                 urb->dev = udev;
                 if (retval == 0 && usb_pipein (urb->pipe))
-                        retval = simple_check_buf (urb);
+                        retval = simple_check_buf(tdev, urb);
 
                 if (vary) {
                         int     len = urb->transfer_buffer_length;
@@ -341,7 +322,7 @@ static int simple_io (
         urb->transfer_buffer_length = max;
 
         if (expected != retval)
-                dev_dbg (&udev->dev,
+                dev_err(&udev->dev,
                         "%s failed, iterations left %d, status %d (not %d)\n",
                                 label, iterations, retval, expected);
         return retval;
@@ -357,7 +338,7 @@ static int simple_io (
 static void free_sglist (struct scatterlist *sg, int nents)
 {
         unsigned                i;
-        
+
         if (!sg)
                 return;
         for (i = 0; i < nents; i++) {
@@ -415,7 +396,7 @@ alloc_sglist (int nents, int max, int vary)
 }
 
 static int perform_sglist (
-        struct usb_device       *udev,
+        struct usbtest_dev      *tdev,
         unsigned                iterations,
         int                     pipe,
         struct usb_sg_request   *req,
@@ -423,6 +404,7 @@ static int perform_sglist (
         int                     nents
 )
 {
+        struct usb_device       *udev = testdev_to_usbdev(tdev);
         int                     retval = 0;
 
         while (retval == 0 && iterations-- > 0) {
@@ -431,7 +413,7 @@ static int perform_sglist (
                                         ? (INTERRUPT_RATE << 3)
                                         : INTERRUPT_RATE,
                                 sg, nents, 0, GFP_KERNEL);
-                
+
                 if (retval)
                         break;
                 usb_sg_wait (req);
@@ -446,7 +428,8 @@ static int perform_sglist (
         // failure if retval is as we expected ...
 
         if (retval)
-                dbg ("perform_sglist failed, iterations left %d, status %d",
+                ERROR(tdev, "perform_sglist failed, "
+                                "iterations left %d, status %d\n",
                                 iterations, retval);
         return retval;
 }
@@ -505,28 +488,28 @@ static int set_altsetting (struct usbtest_dev *dev, int alternate)
                         alternate);
 }
 
-static int is_good_config (char *buf, int len)
+static int is_good_config(struct usbtest_dev *tdev, int len)
 {
         struct usb_config_descriptor    *config;
-        
+
         if (len < sizeof *config)
                 return 0;
-        config = (struct usb_config_descriptor *) buf;
+        config = (struct usb_config_descriptor *) tdev->buf;
 
         switch (config->bDescriptorType) {
         case USB_DT_CONFIG:
         case USB_DT_OTHER_SPEED_CONFIG:
                 if (config->bLength != 9) {
-                        dbg ("bogus config descriptor length");
+                        ERROR(tdev, "bogus config descriptor length\n");
                         return 0;
                 }
                 /* this bit 'must be 1' but often isn't */
                 if (!realworld && !(config->bmAttributes & 0x80)) {
-                        dbg ("high bit of config attributes not set");
+                        ERROR(tdev, "high bit of config attributes not set\n");
                         return 0;
                 }
                 if (config->bmAttributes & 0x1f) {      /* reserved == 0 */
-                        dbg ("reserved config bits set");
+                        ERROR(tdev, "reserved config bits set\n");
                         return 0;
                 }
                 break;
@@ -538,7 +521,7 @@ static int is_good_config (char *buf, int len)
                 return 1;
         if (le16_to_cpu(config->wTotalLength) >= TBUF_SIZE)             /* max partial read */
                 return 1;
-        dbg ("bogus config descriptor read size");
+        ERROR(tdev, "bogus config descriptor read size\n");
         return 0;
 }
 
@@ -571,7 +554,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                 /* 9.2.3 constrains the range here */
                 alt = iface->altsetting [i].desc.bAlternateSetting;
                 if (alt < 0 || alt >= iface->num_altsetting) {
-                        dev_dbg (&iface->dev,
+                        dev_err(&iface->dev,
                                         "invalid alt [%d].bAltSetting = %d\n",
                                         i, alt);
                 }
@@ -583,7 +566,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                 /* [9.4.10] set_interface */
                 retval = set_altsetting (dev, alt);
                 if (retval) {
-                        dev_dbg (&iface->dev, "can't set_interface = %d, %d\n",
+                        dev_err(&iface->dev, "can't set_interface = %d, %d\n",
                                         alt, retval);
                         return retval;
                 }
@@ -591,7 +574,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                 /* [9.4.4] get_interface always works */
                 retval = get_altsetting (dev);
                 if (retval != alt) {
-                        dev_dbg (&iface->dev, "get alt should be %d, was %d\n",
+                        dev_err(&iface->dev, "get alt should be %d, was %d\n",
                                         alt, retval);
                         return (retval < 0) ? retval : -EDOM;
                 }
@@ -611,7 +594,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                                 USB_DIR_IN | USB_RECIP_DEVICE,
                                 0, 0, dev->buf, 1, USB_CTRL_GET_TIMEOUT);
                 if (retval != 1 || dev->buf [0] != expected) {
-                        dev_dbg (&iface->dev, "get config --> %d %d (1 %d)\n",
+                        dev_err(&iface->dev, "get config --> %d %d (1 %d)\n",
                                 retval, dev->buf[0], expected);
                         return (retval < 0) ? retval : -EDOM;
                 }
@@ -621,7 +604,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
         retval = usb_get_descriptor (udev, USB_DT_DEVICE, 0,
                         dev->buf, sizeof udev->descriptor);
         if (retval != sizeof udev->descriptor) {
-                dev_dbg (&iface->dev, "dev descriptor --> %d\n", retval);
+                dev_err(&iface->dev, "dev descriptor --> %d\n", retval);
                 return (retval < 0) ? retval : -EDOM;
         }
 
@@ -629,8 +612,8 @@ static int ch9_postconfig (struct usbtest_dev *dev)
         for (i = 0; i < udev->descriptor.bNumConfigurations; i++) {
                 retval = usb_get_descriptor (udev, USB_DT_CONFIG, i,
                                 dev->buf, TBUF_SIZE);
-                if (!is_good_config (dev->buf, retval)) {
-                        dev_dbg (&iface->dev,
+                if (!is_good_config(dev, retval)) {
+                        dev_err(&iface->dev,
                                         "config [%d] descriptor --> %d\n",
                                         i, retval);
                         return (retval < 0) ? retval : -EDOM;
@@ -650,14 +633,14 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                                 sizeof (struct usb_qualifier_descriptor));
                 if (retval == -EPIPE) {
                         if (udev->speed == USB_SPEED_HIGH) {
-                                dev_dbg (&iface->dev,
+                                dev_err(&iface->dev,
                                                 "hs dev qualifier --> %d\n",
                                                 retval);
                                 return (retval < 0) ? retval : -EDOM;
                         }
                         /* usb2.0 but not high-speed capable; fine */
                 } else if (retval != sizeof (struct usb_qualifier_descriptor)) {
-                        dev_dbg (&iface->dev, "dev qualifier --> %d\n", retval);
+                        dev_err(&iface->dev, "dev qualifier --> %d\n", retval);
                         return (retval < 0) ? retval : -EDOM;
                 } else
                         d = (struct usb_qualifier_descriptor *) dev->buf;
@@ -669,8 +652,8 @@ static int ch9_postconfig (struct usbtest_dev *dev)
                                 retval = usb_get_descriptor (udev,
                                         USB_DT_OTHER_SPEED_CONFIG, i,
                                         dev->buf, TBUF_SIZE);
-                                if (!is_good_config (dev->buf, retval)) {
-                                        dev_dbg (&iface->dev,
+                                if (!is_good_config(dev, retval)) {
+                                        dev_err(&iface->dev,
                                                 "other speed config --> %d\n",
                                                 retval);
                                         return (retval < 0) ? retval : -EDOM;
@@ -683,7 +666,7 @@ static int ch9_postconfig (struct usbtest_dev *dev)
         /* [9.4.5] get_status always works */
         retval = usb_get_status (udev, USB_RECIP_DEVICE, 0, dev->buf);
         if (retval != 2) {
-                dev_dbg (&iface->dev, "get dev status --> %d\n", retval);
+                dev_err(&iface->dev, "get dev status --> %d\n", retval);
                 return (retval < 0) ? retval : -EDOM;
         }
 
@@ -693,11 +676,11 @@ static int ch9_postconfig (struct usbtest_dev *dev)
         retval = usb_get_status (udev, USB_RECIP_INTERFACE,
                         iface->altsetting [0].desc.bInterfaceNumber, dev->buf);
         if (retval != 2) {
-                dev_dbg (&iface->dev, "get interface status --> %d\n", retval);
+                dev_err(&iface->dev, "get interface status --> %d\n", retval);
                 return (retval < 0) ? retval : -EDOM;
         }
         // FIXME get status for each endpoint in the interface
-        
+
         return 0;
 }
 
@@ -752,8 +735,9 @@ static void ctrl_complete (struct urb *urb)
          */
         if (subcase->number > 0) {
                 if ((subcase->number - ctx->last) != 1) {
-                        dbg ("subcase %d completed out of order, last %d",
-                                        subcase->number, ctx->last);
+                        ERROR(ctx->dev,
+                                "subcase %d completed out of order, last %d\n",
+                                subcase->number, ctx->last);
                         status = -EDOM;
                         ctx->last = subcase->number;
                         goto error;
@@ -777,7 +761,7 @@ static void ctrl_complete (struct urb *urb)
                 else if (subcase->number == 12 && status == -EPIPE)
                         status = 0;
                 else
-                        dbg ("subtest %d error, status %d",
+                        ERROR(ctx->dev, "subtest %d error, status %d\n",
                                         subcase->number, status);
         }
 
@@ -788,9 +772,12 @@ error:
                         int             i;
 
                         ctx->status = status;
-                        info ("control queue %02x.%02x, err %d, %d left",
+                        ERROR(ctx->dev, "control queue %02x.%02x, err %d, "
+                                        "%d left, subcase %d, len %d/%d\n",
                                         reqp->bRequestType, reqp->bRequest,
-                                        status, ctx->count);
+                                        status, ctx->count, subcase->number,
+                                        urb->actual_length,
+                                        urb->transfer_buffer_length);
 
                         /* FIXME this "unlink everything" exit route should
                          * be a separate test case.
@@ -799,7 +786,8 @@ error:
                         /* unlink whatever's still pending */
                         for (i = 1; i < ctx->param->sglen; i++) {
                                 struct urb      *u = ctx->urb [
-        (i + subcase->number) % ctx->param->sglen];
+                                                (i + subcase->number)
+                                                % ctx->param->sglen];
 
                                 if (u == urb || !u->dev)
                                         continue;
@@ -812,7 +800,8 @@ error:
                                 case -EIDRM:
                                         continue;
                                 default:
-                                        dbg ("urb unlink --> %d", status);
+                                        ERROR(ctx->dev, "urb unlink --> %d\n",
+                                                        status);
                                 }
                         }
                         status = ctx->status;
@@ -822,14 +811,15 @@ error:
         /* resubmit if we need to, else mark this as done */
         if ((status == 0) && (ctx->pending < ctx->count)) {
                 if ((status = usb_submit_urb (urb, GFP_ATOMIC)) != 0) {
-                        dbg ("can't resubmit ctrl %02x.%02x, err %d",
+                        ERROR(ctx->dev,
+                                "can't resubmit ctrl %02x.%02x, err %d\n",
                                 reqp->bRequestType, reqp->bRequest, status);
                         urb->dev = NULL;
                 } else
                         ctx->pending++;
         } else
                 urb->dev = NULL;
-        
+
         /* signal completion when nothing's queued */
         if (ctx->pending == 0)
                 complete (&ctx->complete);
@@ -866,6 +856,11 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
                 struct urb              *u;
                 struct usb_ctrlrequest  req;
                 struct subcase          *reqp;
+
+                /* sign of this variable means:
+                 *  -: tested code must return this (negative) error code
+                 *  +: tested code may return this (negative too) error code
+                 */
                 int                     expected = 0;
 
                 /* requests here are mostly expected to succeed on any
@@ -918,11 +913,11 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
                         req.wValue = cpu_to_le16 (USB_DT_INTERFACE << 8);
                         // interface == 0
                         len = sizeof (struct usb_interface_descriptor);
-                        expected = EPIPE;
+                        expected = -EPIPE;
                         break;
                 // NOTE: two consecutive stalls in the queue here.
                 // that tests fault recovery a bit more aggressively.
-                case 8:         // clear endpoint halt (USUALLY STALLS)
+                case 8:         // clear endpoint halt (MAY STALL)
                         req.bRequest = USB_REQ_CLEAR_FEATURE;
                         req.bRequestType = USB_RECIP_ENDPOINT;
                         // wValue 0 == ep halt
@@ -965,7 +960,7 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
                         break;
                 case 14:        // short read; try to fill the last packet
                         req.wValue = cpu_to_le16 ((USB_DT_DEVICE << 8) | 0);
-                        // device descriptor size == 18 bytes 
+                        /* device descriptor size == 18 bytes */
                         len = udev->descriptor.bMaxPacketSize0;
                         switch (len) {
                         case 8:         len = 24; break;
@@ -974,7 +969,7 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
                         expected = -EREMOTEIO;
                         break;
                 default:
-                        err ("bogus number of ctrl queue testcases!");
+                        ERROR(dev, "bogus number of ctrl queue testcases!\n");
                         context.status = -EINVAL;
                         goto cleanup;
                 }
@@ -1003,7 +998,7 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
         for (i = 0; i < param->sglen; i++) {
                 context.status = usb_submit_urb (urb [i], GFP_ATOMIC);
                 if (context.status != 0) {
-                        dbg ("can't submit urb[%d], status %d",
+                        ERROR(dev, "can't submit urb[%d], status %d\n",
                                         i, context.status);
                         context.count = context.pending;
                         break;
@@ -1070,7 +1065,7 @@ static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
          * due to errors, or is just NAKing requests.
          */
         if ((retval = usb_submit_urb (urb, GFP_KERNEL)) != 0) {
-                dev_dbg (&dev->intf->dev, "submit fail %d\n", retval);
+                dev_err(&dev->intf->dev, "submit fail %d\n", retval);
                 return retval;
         }
 
@@ -1087,13 +1082,13 @@ retry:
                          * "normal" drivers would prevent resubmission, but
                          * since we're testing unlink paths, we can't.
                          */
-                        dev_dbg (&dev->intf->dev, "unlink retry\n");
+                        ERROR(dev,  "unlink retry\n");
                         goto retry;
                 }
         } else
                 usb_kill_urb (urb);
         if (!(retval == 0 || retval == -EINPROGRESS)) {
-                dev_dbg (&dev->intf->dev, "unlink fail %d\n", retval);
+                dev_err(&dev->intf->dev, "unlink fail %d\n", retval);
                 return retval;
         }
 
@@ -1121,7 +1116,7 @@ static int unlink_simple (struct usbtest_dev *dev, int pipe, int len)
 
 /*-------------------------------------------------------------------------*/
 
-static int verify_not_halted (int ep, struct urb *urb)
+static int verify_not_halted(struct usbtest_dev *tdev, int ep, struct urb *urb)
 {
         int     retval;
         u16     status;
@@ -1129,20 +1124,21 @@ static int verify_not_halted (int ep, struct urb *urb)
         /* shouldn't look or act halted */
         retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
         if (retval < 0) {
-                dbg ("ep %02x couldn't get no-halt status, %d", ep, retval);
+                ERROR(tdev, "ep %02x couldn't get no-halt status, %d\n",
+                                ep, retval);
                 return retval;
         }
         if (status != 0) {
-                dbg ("ep %02x bogus status: %04x != 0", ep, status);
+                ERROR(tdev, "ep %02x bogus status: %04x != 0\n", ep, status);
                 return -EINVAL;
         }
-        retval = simple_io (urb, 1, 0, 0, __func__);
+        retval = simple_io(tdev, urb, 1, 0, 0, __func__);
         if (retval != 0)
                 return -EINVAL;
         return 0;
 }
 
-static int verify_halted (int ep, struct urb *urb)
+static int verify_halted(struct usbtest_dev *tdev, int ep, struct urb *urb)
 {
         int     retval;
         u16     status;
@@ -1150,29 +1146,30 @@ static int verify_halted (int ep, struct urb *urb)
         /* should look and act halted */
         retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
         if (retval < 0) {
-                dbg ("ep %02x couldn't get halt status, %d", ep, retval);
+                ERROR(tdev, "ep %02x couldn't get halt status, %d\n",
+                                ep, retval);
                 return retval;
         }
         le16_to_cpus(&status);
         if (status != 1) {
-                dbg ("ep %02x bogus status: %04x != 1", ep, status);
+                ERROR(tdev, "ep %02x bogus status: %04x != 1\n", ep, status);
                 return -EINVAL;
         }
-        retval = simple_io (urb, 1, 0, -EPIPE, __func__);
+        retval = simple_io(tdev, urb, 1, 0, -EPIPE, __func__);
         if (retval != -EPIPE)
                 return -EINVAL;
-        retval = simple_io (urb, 1, 0, -EPIPE, "verify_still_halted");
+        retval = simple_io(tdev, urb, 1, 0, -EPIPE, "verify_still_halted");
         if (retval != -EPIPE)
                 return -EINVAL;
         return 0;
 }
 
-static int test_halt (int ep, struct urb *urb)
+static int test_halt(struct usbtest_dev *tdev, int ep, struct urb *urb)
 {
         int     retval;
 
         /* shouldn't look or act halted now */
-        retval = verify_not_halted (ep, urb);
+        retval = verify_not_halted(tdev, ep, urb);
         if (retval < 0)
                 return retval;
 
@@ -1182,20 +1179,20 @@ static int test_halt (int ep, struct urb *urb)
                         USB_ENDPOINT_HALT, ep,
                         NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (retval < 0) {
-                dbg ("ep %02x couldn't set halt, %d", ep, retval);
+                ERROR(tdev, "ep %02x couldn't set halt, %d\n", ep, retval);
                 return retval;
         }
-        retval = verify_halted (ep, urb);
+        retval = verify_halted(tdev, ep, urb);
         if (retval < 0)
                 return retval;
 
         /* clear halt (tests API + protocol), verify it worked */
         retval = usb_clear_halt (urb->dev, urb->pipe);
         if (retval < 0) {
-                dbg ("ep %02x couldn't clear halt, %d", ep, retval);
+                ERROR(tdev, "ep %02x couldn't clear halt, %d\n", ep, retval);
                 return retval;
         }
-        retval = verify_not_halted (ep, urb);
+        retval = verify_not_halted(tdev, ep, urb);
         if (retval < 0)
                 return retval;
 
@@ -1217,7 +1214,7 @@ static int halt_simple (struct usbtest_dev *dev)
         if (dev->in_pipe) {
                 ep = usb_pipeendpoint (dev->in_pipe) | USB_DIR_IN;
                 urb->pipe = dev->in_pipe;
-                retval = test_halt (ep, urb);
+                retval = test_halt(dev, ep, urb);
                 if (retval < 0)
                         goto done;
         }
@@ -1225,7 +1222,7 @@ static int halt_simple (struct usbtest_dev *dev)
         if (dev->out_pipe) {
                 ep = usb_pipeendpoint (dev->out_pipe);
                 urb->pipe = dev->out_pipe;
-                retval = test_halt (ep, urb);
+                retval = test_halt(dev, ep, urb);
         }
 done:
         simple_free_urb (urb);
@@ -1275,7 +1272,7 @@ static int ctrl_out (struct usbtest_dev *dev,
                 if (retval != len) {
                         what = "write";
                         if (retval >= 0) {
-                                INFO(dev, "ctrl_out, wlen %d (expected %d)\n",
+                                ERROR(dev, "ctrl_out, wlen %d (expected %d)\n",
                                                 retval, len);
                                 retval = -EBADMSG;
                         }
@@ -1289,7 +1286,7 @@ static int ctrl_out (struct usbtest_dev *dev,
                 if (retval != len) {
                         what = "read";
                         if (retval >= 0) {
-                                INFO(dev, "ctrl_out, rlen %d (expected %d)\n",
+                                ERROR(dev, "ctrl_out, rlen %d (expected %d)\n",
                                                 retval, len);
                                 retval = -EBADMSG;
                         }
@@ -1299,7 +1296,7 @@ static int ctrl_out (struct usbtest_dev *dev,
                 /* fail if we can't verify */
                 for (j = 0; j < len; j++) {
                         if (buf [j] != (u8) (i + j)) {
-                                INFO (dev, "ctrl_out, byte %d is %d not %d\n",
+                                ERROR(dev, "ctrl_out, byte %d is %d not %d\n",
                                         j, buf [j], (u8) i + j);
                                 retval = -EBADMSG;
                                 break;
@@ -1321,7 +1318,7 @@ static int ctrl_out (struct usbtest_dev *dev,
         }
 
         if (retval < 0)
-                INFO (dev, "ctrl_out %s failed, code %d, count %d\n",
+                ERROR (dev, "ctrl_out %s failed, code %d, count %d\n",
                         what, retval, i);
 
         kfree (buf);
@@ -1366,7 +1363,7 @@ static void iso_callback (struct urb *urb)
                 case 0:
                         goto done;
                 default:
-                        dev_dbg (&ctx->dev->intf->dev,
+                        dev_err(&ctx->dev->intf->dev,
                                         "iso resubmit err %d\n",
                                         status);
                         /* FALLTHROUGH */
@@ -1381,7 +1378,7 @@ static void iso_callback (struct urb *urb)
         ctx->pending--;
         if (ctx->pending == 0) {
                 if (ctx->errors)
-                        dev_dbg (&ctx->dev->intf->dev,
+                        dev_err(&ctx->dev->intf->dev,
                                 "iso test, %lu errors out of %lu\n",
                                 ctx->errors, ctx->packet_count);
                 complete (&ctx->done);
@@ -1458,7 +1455,7 @@ test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
 
         memset (urbs, 0, sizeof urbs);
         udev = testdev_to_usbdev (dev);
-        dev_dbg (&dev->intf->dev,
+        dev_info(&dev->intf->dev,
                 "... iso period %d %sframes, wMaxPacket %04x\n",
                 1 << (desc->bInterval - 1),
                 (udev->speed == USB_SPEED_HIGH) ? "micro" : "",
@@ -1475,7 +1472,7 @@ test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
                 urbs [i]->context = &context;
         }
         packets *= param->iterations;
-        dev_dbg (&dev->intf->dev,
+        dev_info(&dev->intf->dev,
                 "... total %lu msec (%lu packets)\n",
                 (packets * (1 << (desc->bInterval - 1)))
                         / ((udev->speed == USB_SPEED_HIGH) ? 8 : 1),
@@ -1537,6 +1534,13 @@ fail:
  * except indirectly by consuming USB bandwidth and CPU resources for test
  * threads and request completion.  But the only way to know that for sure
  * is to test when HC queues are in use by many devices.
+ *
+ * WARNING:  Because usbfs grabs udev->dev.sem before calling this ioctl(),
+ * it locks out usbcore in certain code paths.  Notably, if you disconnect
+ * the device-under-test, khubd will wait block forever waiting for the
+ * ioctl to complete ... so that usb_disconnect() can abort the pending
+ * urbs and then call usbtest_disconnect().  To abort a test, you're best
+ * off just killing the userspace task and waiting for it to exit.
  */
 
 static int
@@ -1575,7 +1579,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
          * altsettings; force a default so most tests don't need to check.
          */
         if (dev->info->alt >= 0) {
-                int     res;
+                int     res;
 
                 if (intf->altsetting->desc.bInterfaceNumber) {
                         mutex_unlock(&dev->lock);
@@ -1604,7 +1608,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
         switch (param->test_num) {
 
         case 0:
-                dev_dbg (&intf->dev, "TEST 0:  NOP\n");
+                dev_info(&intf->dev, "TEST 0:  NOP\n");
                 retval = 0;
                 break;
 
@@ -1612,7 +1616,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
         case 1:
                 if (dev->out_pipe == 0)
                         break;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                                 "TEST 1:  write %d bytes %u times\n",
                                 param->length, param->iterations);
                 urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
@@ -1621,13 +1625,13 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         break;
                 }
                 // FIRMWARE:  bulk sink (maybe accepts short writes)
-                retval = simple_io (urb, param->iterations, 0, 0, "test1");
+                retval = simple_io(dev, urb, param->iterations, 0, 0, "test1");
                 simple_free_urb (urb);
                 break;
         case 2:
                 if (dev->in_pipe == 0)
                         break;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                                 "TEST 2:  read %d bytes %u times\n",
                                 param->length, param->iterations);
                 urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
@@ -1636,13 +1640,13 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         break;
                 }
                 // FIRMWARE:  bulk source (maybe generates short writes)
-                retval = simple_io (urb, param->iterations, 0, 0, "test2");
+                retval = simple_io(dev, urb, param->iterations, 0, 0, "test2");
                 simple_free_urb (urb);
                 break;
         case 3:
                 if (dev->out_pipe == 0 || param->vary == 0)
                         break;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                                 "TEST 3:  write/%d 0..%d bytes %u times\n",
                                 param->vary, param->length, param->iterations);
                 urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
@@ -1651,14 +1655,14 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         break;
                 }
                 // FIRMWARE:  bulk sink (maybe accepts short writes)
-                retval = simple_io (urb, param->iterations, param->vary,
+                retval = simple_io(dev, urb, param->iterations, param->vary,
                                         0, "test3");
                 simple_free_urb (urb);
                 break;
         case 4:
                 if (dev->in_pipe == 0 || param->vary == 0)
                         break;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                                 "TEST 4:  read/%d 0..%d bytes %u times\n",
                                 param->vary, param->length, param->iterations);
                 urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
@@ -1667,7 +1671,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         break;
                 }
                 // FIRMWARE:  bulk source (maybe generates short writes)
-                retval = simple_io (urb, param->iterations, param->vary,
+                retval = simple_io(dev, urb, param->iterations, param->vary,
                                         0, "test4");
                 simple_free_urb (urb);
                 break;
@@ -1676,7 +1680,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
         case 5:
                 if (dev->out_pipe == 0 || param->sglen == 0)
                         break;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                         "TEST 5:  write %d sglists %d entries of %d bytes\n",
                                 param->iterations,
                                 param->sglen, param->length);
@@ -1686,7 +1690,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         break;
                 }
                 // FIRMWARE:  bulk sink (maybe accepts short writes)
-                retval = perform_sglist (udev, param->iterations, dev->out_pipe,
+                retval = perform_sglist(dev, param->iterations, dev->out_pipe,
                                 &req, sg, param->sglen);
                 free_sglist (sg, param->sglen);
                 break;
@@ -1694,7 +1698,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
         case 6:
                 if (dev->in_pipe == 0 || param->sglen == 0)
                         break;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                         "TEST 6:  read %d sglists %d entries of %d bytes\n",
                                 param->iterations,
                                 param->sglen, param->length);
@@ -1704,14 +1708,14 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         break;
                 }
                 // FIRMWARE:  bulk source (maybe generates short writes)
-                retval = perform_sglist (udev, param->iterations, dev->in_pipe,
+                retval = perform_sglist(dev, param->iterations, dev->in_pipe,
                                 &req, sg, param->sglen);
                 free_sglist (sg, param->sglen);
                 break;
         case 7:
                 if (dev->out_pipe == 0 || param->sglen == 0 || param->vary == 0)
                         break;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                         "TEST 7:  write/%d %d sglists %d entries 0..%d bytes\n",
                                 param->vary, param->iterations,
                                 param->sglen, param->length);
@@ -1721,14 +1725,14 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         break;
                 }
                 // FIRMWARE:  bulk sink (maybe accepts short writes)
-                retval = perform_sglist (udev, param->iterations, dev->out_pipe,
+                retval = perform_sglist(dev, param->iterations, dev->out_pipe,
                                 &req, sg, param->sglen);
                 free_sglist (sg, param->sglen);
                 break;
         case 8:
                 if (dev->in_pipe == 0 || param->sglen == 0 || param->vary == 0)
                         break;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                         "TEST 8:  read/%d %d sglists %d entries 0..%d bytes\n",
                                 param->vary, param->iterations,
                                 param->sglen, param->length);
@@ -1738,7 +1742,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                         break;
                 }
                 // FIRMWARE:  bulk source (maybe generates short writes)
-                retval = perform_sglist (udev, param->iterations, dev->in_pipe,
+                retval = perform_sglist(dev, param->iterations, dev->in_pipe,
                                 &req, sg, param->sglen);
                 free_sglist (sg, param->sglen);
                 break;
@@ -1746,13 +1750,14 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
         /* non-queued sanity tests for control (chapter 9 subset) */
         case 9:
                 retval = 0;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                         "TEST 9:  ch9 (subset) control tests, %d times\n",
                                 param->iterations);
                 for (i = param->iterations; retval == 0 && i--; /* NOP */)
                         retval = ch9_postconfig (dev);
                 if (retval)
-                        dbg ("ch9 subset failed, iterations left %d", i);
+                        dev_err(&intf->dev, "ch9 subset failed, "
+                                        "iterations left %d\n", i);
                 break;
 
         /* queued control messaging */
@@ -1760,7 +1765,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 if (param->sglen == 0)
                         break;
                 retval = 0;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                                 "TEST 10:  queue %d control calls, %d times\n",
                                 param->sglen,
                                 param->iterations);
@@ -1772,26 +1777,26 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 if (dev->in_pipe == 0 || !param->length)
                         break;
                 retval = 0;
-                dev_dbg (&intf->dev, "TEST 11:  unlink %d reads of %d\n",
+                dev_info(&intf->dev, "TEST 11:  unlink %d reads of %d\n",
                                 param->iterations, param->length);
                 for (i = param->iterations; retval == 0 && i--; /* NOP */)
                         retval = unlink_simple (dev, dev->in_pipe,
                                                 param->length);
                 if (retval)
-                        dev_dbg (&intf->dev, "unlink reads failed %d, "
+                        dev_err(&intf->dev, "unlink reads failed %d, "
                                 "iterations left %d\n", retval, i);
                 break;
         case 12:
                 if (dev->out_pipe == 0 || !param->length)
                         break;
                 retval = 0;
-                dev_dbg (&intf->dev, "TEST 12:  unlink %d writes of %d\n",
+                dev_info(&intf->dev, "TEST 12:  unlink %d writes of %d\n",
                                 param->iterations, param->length);
                 for (i = param->iterations; retval == 0 && i--; /* NOP */)
                         retval = unlink_simple (dev, dev->out_pipe,
                                                 param->length);
                 if (retval)
-                        dev_dbg (&intf->dev, "unlink writes failed %d, "
+                        dev_err(&intf->dev, "unlink writes failed %d, "
                                 "iterations left %d\n", retval, i);
                 break;
 
@@ -1800,24 +1805,24 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 if (dev->out_pipe == 0 && dev->in_pipe == 0)
                         break;
                 retval = 0;
-                dev_dbg (&intf->dev, "TEST 13:  set/clear %d halts\n",
+                dev_info(&intf->dev, "TEST 13:  set/clear %d halts\n",
                                 param->iterations);
                 for (i = param->iterations; retval == 0 && i--; /* NOP */)
                         retval = halt_simple (dev);
-                
+
                 if (retval)
-                        DBG (dev, "halts failed, iterations left %d\n", i);
+                        ERROR(dev, "halts failed, iterations left %d\n", i);
                 break;
 
         /* control write tests */
         case 14:
                 if (!dev->info->ctrl_out)
                         break;
-                dev_dbg (&intf->dev, "TEST 14:  %d ep0out, %d..%d vary %d\n",
+                dev_info(&intf->dev, "TEST 14:  %d ep0out, %d..%d vary %d\n",
                                 param->iterations,
                                 realworld ? 1 : 0, param->length,
                                 param->vary);
-                retval = ctrl_out (dev, param->iterations, 
+                retval = ctrl_out(dev, param->iterations,
                                 param->length, param->vary);
                 break;
 
@@ -1825,7 +1830,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
         case 15:
                 if (dev->out_iso_pipe == 0 || param->sglen == 0)
                         break;
-                dev_dbg (&intf->dev, 
+                dev_info(&intf->dev,
                         "TEST 15:  write %d iso, %d entries of %d bytes\n",
                                 param->iterations,
                                 param->sglen, param->length);
@@ -1838,7 +1843,7 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
         case 16:
                 if (dev->in_iso_pipe == 0 || param->sglen == 0)
                         break;
-                dev_dbg (&intf->dev,
+                dev_info(&intf->dev,
                         "TEST 16:  read %d iso, %d entries of %d bytes\n",
                                 param->iterations,
                                 param->sglen, param->length);
@@ -1898,7 +1903,8 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
                         return -ENODEV;
                 if (product && le16_to_cpu(udev->descriptor.idProduct) != (u16)product)
                         return -ENODEV;
-                dbg ("matched module params, vend=0x%04x prod=0x%04x",
+                dev_info(&intf->dev, "matched module params, "
+                                        "vend=0x%04x prod=0x%04x\n",
                                 le16_to_cpu(udev->descriptor.idVendor),
                                 le16_to_cpu(udev->descriptor.idProduct));
         }
@@ -1940,7 +1946,8 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
 
                         status = get_endpoints (dev, intf);
                         if (status < 0) {
-                                dbg ("couldn't get endpoints, %d\n", status);
+                                WARN(dev, "couldn't get endpoints, %d\n",
+                                                status);
                                 return status;
                         }
                         /* may find bulk or ISO pipes */
@@ -2082,21 +2089,9 @@ static struct usbtest_info generic_info = {
 };
 #endif
 
-// FIXME remove this 
-static struct usbtest_info hact_info = {
-        .name           = "FX2/hact",
-        //.ep_in                = 6,
-        .ep_out         = 2,
-        .alt            = -1,
-};
-
 
 static struct usb_device_id id_table [] = {
 
-        { USB_DEVICE (0x0547, 0x1002),
-                .driver_info = (unsigned long) &hact_info,
-                },
-
         /*-------------------------------------------------------------*/
 
         /* EZ-USB devices which download firmware to replace (or in our
@@ -2185,7 +2180,7 @@ static int __init usbtest_init (void)
 {
 #ifdef GENERIC
         if (vendor)
-                dbg ("params: vend=0x%04x prod=0x%04x", vendor, product);
+                pr_debug("params: vend=0x%04x prod=0x%04x\n", vendor, product);
 #endif
         return usb_register (&usbtest_driver);
 }
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index 2cffec85ee7e..9ba64ccc1359 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -447,6 +447,15 @@ config USB_SERIAL_MOS7840
           To compile this driver as a module, choose M here: the
           module will be called mos7840.  If unsure, choose N.
 
+config USB_SERIAL_MOTOROLA
+        tristate "USB Motorola Phone modem driver"
+        ---help---
+          Say Y here if you want to use a Motorola phone with a USB
+          connector as a modem link.
+
+          To compile this driver as a module, choose M here: the
+          module will be called moto_modem.  If unsure, choose N.
+
 config USB_SERIAL_NAVMAN
         tristate "USB Navman GPS device"
         help
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 756859510d8c..17a762ab6769 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -39,6 +39,7 @@ obj-$(CONFIG_USB_SERIAL_KOBIL_SCT)		+= kobil_sct.o
 obj-$(CONFIG_USB_SERIAL_MCT_U232)               += mct_u232.o
 obj-$(CONFIG_USB_SERIAL_MOS7720)                += mos7720.o
 obj-$(CONFIG_USB_SERIAL_MOS7840)                += mos7840.o
+obj-$(CONFIG_USB_SERIAL_MOTOROLA)               += moto_modem.o
 obj-$(CONFIG_USB_SERIAL_NAVMAN)                 += navman.o
 obj-$(CONFIG_USB_SERIAL_OMNINET)                += omninet.o
 obj-$(CONFIG_USB_SERIAL_OPTION)                 += option.o
diff --git a/drivers/usb/serial/aircable.c b/drivers/usb/serial/aircable.c
index 9b1bb347dc2d..db6f97a93c02 100644
--- a/drivers/usb/serial/aircable.c
+++ b/drivers/usb/serial/aircable.c
@@ -147,7 +147,7 @@ static void serial_buf_free(struct circ_buf *cb)
  */
 static int serial_buf_data_avail(struct circ_buf *cb)
 {
-        return CIRC_CNT(cb->head,cb->tail,AIRCABLE_BUF_SIZE);
+        return CIRC_CNT(cb->head, cb->tail, AIRCABLE_BUF_SIZE);
 }
 
 /*
@@ -171,7 +171,7 @@ static int serial_buf_put(struct circ_buf *cb, const char *buf, int count)
                 cb->head = (cb->head + c) & (AIRCABLE_BUF_SIZE-1);
                 buf += c;
                 count -= c;
-                ret= c;
+                ret = c;
         }
         return ret;
 }
@@ -197,7 +197,7 @@ static int serial_buf_get(struct circ_buf *cb, char *buf, int count)
                 cb->tail = (cb->tail + c) & (AIRCABLE_BUF_SIZE-1);
                 buf += c;
                 count -= c;
-                ret= c;
+                ret = c;
         }
         return ret;
 }
@@ -208,7 +208,7 @@ static void aircable_send(struct usb_serial_port *port)
 {
         int count, result;
         struct aircable_private *priv = usb_get_serial_port_data(port);
-        unsigned char* buf;
+        unsigned char *buf;
         __le16 *dbuf;
         dbg("%s - port %d", __func__, port->number);
         if (port->write_urb_busy)
@@ -229,7 +229,8 @@ static void aircable_send(struct usb_serial_port *port)
         buf[1] = TX_HEADER_1;
         dbuf = (__le16 *)&buf[2];
         *dbuf = cpu_to_le16((u16)count);
-        serial_buf_get(priv->tx_buf,buf + HCI_HEADER_LENGTH, MAX_HCI_FRAMESIZE);
+        serial_buf_get(priv->tx_buf, buf + HCI_HEADER_LENGTH,
+                                                        MAX_HCI_FRAMESIZE);
 
         memcpy(port->write_urb->transfer_buffer, buf,
                count + HCI_HEADER_LENGTH);
@@ -261,7 +262,7 @@ static void aircable_read(struct work_struct *work)
         struct tty_struct *tty;
         unsigned char *data;
         int count;
-        if (priv->rx_flags & THROTTLED){
+        if (priv->rx_flags & THROTTLED) {
                 if (priv->rx_flags & ACTUALLY_THROTTLED)
                         schedule_work(&priv->rx_work);
                 return;
@@ -282,10 +283,10 @@ static void aircable_read(struct work_struct *work)
         count = min(64, serial_buf_data_avail(priv->rx_buf));
 
         if (count <= 0)
-                return; //We have finished sending everything.
+                return; /* We have finished sending everything. */
 
         tty_prepare_flip_string(tty, &data, count);
-        if (!data){
+        if (!data) {
                 err("%s- kzalloc(%d) failed.", __func__, count);
                 return;
         }
@@ -304,9 +305,10 @@ static void aircable_read(struct work_struct *work)
 static int aircable_probe(struct usb_serial *serial,
                           const struct usb_device_id *id)
 {
-        struct usb_host_interface *iface_desc = serial->interface->cur_altsetting;
+        struct usb_host_interface *iface_desc = serial->interface->
+                                                                cur_altsetting;
         struct usb_endpoint_descriptor *endpoint;
-        int num_bulk_out=0;
+        int num_bulk_out = 0;
         int i;
 
         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
@@ -325,13 +327,13 @@ static int aircable_probe(struct usb_serial *serial,
         return 0;
 }
 
-static int aircable_attach (struct usb_serial *serial)
+static int aircable_attach(struct usb_serial *serial)
 {
         struct usb_serial_port *port = serial->port[0];
         struct aircable_private *priv;
 
         priv = kzalloc(sizeof(struct aircable_private), GFP_KERNEL);
-        if (!priv){
+        if (!priv) {
                 err("%s- kmalloc(%Zd) failed.", __func__,
                         sizeof(struct aircable_private));
                 return -ENOMEM;
@@ -392,7 +394,7 @@ static int aircable_write(struct usb_serial_port *port,
 
         usb_serial_debug_data(debug, &port->dev, __func__, count, source);
 
-        if (!count){
+        if (!count) {
                 dbg("%s - write request of 0 bytes", __func__);
                 return count;
         }
@@ -418,31 +420,31 @@ static void aircable_write_bulk_callback(struct urb *urb)
 
         /* This has been taken from cypress_m8.c cypress_write_int_callback */
         switch (status) {
-                case 0:
-                        /* success */
-                        break;
-                case -ECONNRESET:
-                case -ENOENT:
-                case -ESHUTDOWN:
-                        /* this urb is terminated, clean up */
-                        dbg("%s - urb shutting down with status: %d",
-                            __func__, status);
-                        port->write_urb_busy = 0;
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d",
+                    __func__, status);
+                port->write_urb_busy = 0;
+                return;
+        default:
+                /* error in the urb, so we have to resubmit it */
+                dbg("%s - Overflow in write", __func__);
+                dbg("%s - nonzero write bulk status received: %d",
+                    __func__, status);
+                port->write_urb->transfer_buffer_length = 1;
+                port->write_urb->dev = port->serial->dev;
+                result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
+                if (result)
+                        dev_err(&urb->dev->dev,
+                            "%s - failed resubmitting write urb, error %d\n",
+                                                        __func__, result);
+                else
                         return;
-                default:
-                        /* error in the urb, so we have to resubmit it */
-                        dbg("%s - Overflow in write", __func__);
-                        dbg("%s - nonzero write bulk status received: %d",
-                            __func__, status);
-                        port->write_urb->transfer_buffer_length = 1;
-                        port->write_urb->dev = port->serial->dev;
-                        result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
-                        if (result)
-                                dev_err(&urb->dev->dev,
-                                        "%s - failed resubmitting write urb, error %d\n",
-                                        __func__, result);
-                        else
-                                return;
         }
 
         port->write_urb_busy = 0;
@@ -472,11 +474,11 @@ static void aircable_read_bulk_callback(struct urb *urb)
                         dbg("%s - caught -EPROTO, resubmitting the urb",
                             __func__);
                         usb_fill_bulk_urb(port->read_urb, port->serial->dev,
-                                          usb_rcvbulkpipe(port->serial->dev,
-                                                          port->bulk_in_endpointAddress),
-                                          port->read_urb->transfer_buffer,
-                                          port->read_urb->transfer_buffer_length,
-                                          aircable_read_bulk_callback, port);
+                                usb_rcvbulkpipe(port->serial->dev,
+                                        port->bulk_in_endpointAddress),
+                                port->read_urb->transfer_buffer,
+                                port->read_urb->transfer_buffer_length,
+                                aircable_read_bulk_callback, port);
 
                         result = usb_submit_urb(urb, GFP_ATOMIC);
                         if (result)
@@ -490,7 +492,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
         }
 
         usb_serial_debug_data(debug, &port->dev, __func__,
-                                urb->actual_length,urb->transfer_buffer);
+                                urb->actual_length, urb->transfer_buffer);
 
         tty = port->tty;
         if (tty && urb->actual_length) {
@@ -507,9 +509,9 @@ static void aircable_read_bulk_callback(struct urb *urb)
                         no_packages = urb->actual_length / (HCI_COMPLETE_FRAME);
 
                         if (urb->actual_length % HCI_COMPLETE_FRAME != 0)
-                                no_packages+=1;
+                                no_packages++;
 
-                        for (i = 0; i < no_packages ;i++) {
+                        for (i = 0; i < no_packages; i++) {
                                 if (remaining > (HCI_COMPLETE_FRAME))
                                         package_length = HCI_COMPLETE_FRAME;
                                 else
@@ -529,7 +531,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
         if (port->open_count) {
                 usb_fill_bulk_urb(port->read_urb, port->serial->dev,
                                   usb_rcvbulkpipe(port->serial->dev,
-                                                  port->bulk_in_endpointAddress),
+                                          port->bulk_in_endpointAddress),
                                   port->read_urb->transfer_buffer,
                                   port->read_urb->transfer_buffer_length,
                                   aircable_read_bulk_callback, port);
@@ -602,7 +604,7 @@ static struct usb_serial_driver aircable_device = {
         .unthrottle =           aircable_unthrottle,
 };
 
-static int __init aircable_init (void)
+static int __init aircable_init(void)
 {
         int retval;
         retval = usb_serial_register(&aircable_device);
@@ -619,7 +621,7 @@ failed_usb_register:
         return retval;
 }
 
-static void __exit aircable_exit (void)
+static void __exit aircable_exit(void)
 {
         usb_deregister(&aircable_driver);
         usb_serial_deregister(&aircable_device);
diff --git a/drivers/usb/serial/airprime.c b/drivers/usb/serial/airprime.c
index 725b6b94c274..0798c14ce787 100644
--- a/drivers/usb/serial/airprime.c
+++ b/drivers/usb/serial/airprime.c
@@ -68,8 +68,9 @@ static int airprime_send_setup(struct usb_serial_port *port)
                         val |= 0x02;
 
                 return usb_control_msg(serial->dev,
-                                usb_rcvctrlpipe(serial->dev, 0),
-                                0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
+                                        usb_rcvctrlpipe(serial->dev, 0),
+                                        0x22, 0x21, val, 0, NULL, 0,
+                                        USB_CTRL_SET_TIMEOUT);
         }
 
         return 0;
@@ -90,17 +91,19 @@ static void airprime_read_bulk_callback(struct urb *urb)
                     __func__, status);
                 return;
         }
-        usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
+        usb_serial_debug_data(debug, &port->dev, __func__,
+                                                urb->actual_length, data);
 
         tty = port->tty;
         if (tty && urb->actual_length) {
-                tty_insert_flip_string (tty, data, urb->actual_length);
-                tty_flip_buffer_push (tty);
+                tty_insert_flip_string(tty, data, urb->actual_length);
+                tty_flip_buffer_push(tty);
         }
 
-        result = usb_submit_urb (urb, GFP_ATOMIC);
+        result = usb_submit_urb(urb, GFP_ATOMIC);
         if (result)
-                dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n",
+                dev_err(&port->dev,
+                        "%s - failed resubmitting read urb, error %d\n",
                         __func__, result);
         return;
 }
@@ -115,7 +118,7 @@ static void airprime_write_bulk_callback(struct urb *urb)
         dbg("%s - port %d", __func__, port->number);
 
         /* free up the transfer buffer, as usb_free_urb() does not do this */
-        kfree (urb->transfer_buffer);
+        kfree(urb->transfer_buffer);
 
         if (status)
                 dbg("%s - nonzero write bulk status received: %d",
@@ -171,7 +174,7 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
                 }
                 usb_fill_bulk_urb(urb, serial->dev,
                                   usb_rcvbulkpipe(serial->dev,
-                                                  port->bulk_out_endpointAddress),
+                                          port->bulk_out_endpointAddress),
                                   buffer, buffer_size,
                                   airprime_read_bulk_callback, port);
                 result = usb_submit_urb(urb, GFP_KERNEL);
@@ -183,7 +186,8 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
                                 __func__, i, port->number, result);
                         goto errout;
                 }
-                /* remember this urb so we can kill it when the port is closed */
+                /* remember this urb so we can kill it when the
+                   port is closed */
                 priv->read_urbp[i] = urb;
         }
 
@@ -192,22 +196,22 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
         goto out;
 
  errout:
-        /* some error happened, cancel any submitted urbs and clean up anything that
-           got allocated successfully */
+        /* some error happened, cancel any submitted urbs and clean up
+           anything that got allocated successfully */
 
         while (i-- != 0) {
                 urb = priv->read_urbp[i];
                 buffer = urb->transfer_buffer;
-                usb_kill_urb (urb);
-                usb_free_urb (urb);
-                kfree (buffer);
+                usb_kill_urb(urb);
+                usb_free_urb(urb);
+                kfree(buffer);
         }
 
  out:
         return result;
 }
 
-static void airprime_close(struct usb_serial_port *port, struct file * filp)
+static void airprime_close(struct usb_serial_port *port, struct file *filp)
 {
         struct airprime_private *priv = usb_get_serial_port_data(port);
         int i;
@@ -220,16 +224,16 @@ static void airprime_close(struct usb_serial_port *port, struct file * filp)
         mutex_lock(&port->serial->disc_mutex);
         if (!port->serial->disconnected)
                 airprime_send_setup(port);
-        mutex_lock(&port->serial->disc_mutex);
+        mutex_unlock(&port->serial->disc_mutex);
 
         for (i = 0; i < NUM_READ_URBS; ++i) {
-                usb_kill_urb (priv->read_urbp[i]);
-                kfree (priv->read_urbp[i]->transfer_buffer);
-                usb_free_urb (priv->read_urbp[i]);
+                usb_kill_urb(priv->read_urbp[i]);
+                kfree(priv->read_urbp[i]->transfer_buffer);
+                usb_free_urb(priv->read_urbp[i]);
         }
 
         /* free up private structure */
-        kfree (priv);
+        kfree(priv);
         usb_set_serial_port_data(port, NULL);
 }
 
@@ -259,10 +263,10 @@ static int airprime_write(struct usb_serial_port *port,
         urb = usb_alloc_urb(0, GFP_ATOMIC);
         if (!urb) {
                 dev_err(&port->dev, "no more free urbs\n");
-                kfree (buffer);
+                kfree(buffer);
                 return -ENOMEM;
         }
-        memcpy (buffer, buf, count);
+        memcpy(buffer, buf, count);
 
         usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
 
@@ -279,7 +283,7 @@ static int airprime_write(struct usb_serial_port *port,
                         "%s - usb_submit_urb(write bulk) failed with status = %d\n",
                         __func__, status);
                 count = status;
-                kfree (buffer);
+                kfree(buffer);
         } else {
                 spin_lock_irqsave(&priv->lock, flags);
                 ++priv->outstanding_urbs;
@@ -287,7 +291,7 @@ static int airprime_write(struct usb_serial_port *port,
         }
         /* we are done with this urb, so let the host driver
          * really free it when it is finished with it */
-        usb_free_urb (urb);
+        usb_free_urb(urb);
         return count;
 }
 
@@ -315,8 +319,10 @@ static int __init airprime_init(void)
 {
         int retval;
 
-        airprime_device.num_ports =
-                (endpoints > 0 && endpoints <= MAX_BULK_EPS) ? endpoints : NUM_BULK_EPS;
+        airprime_device.num_ports = endpoints;
+        if (endpoints < 0 || endpoints >= MAX_BULK_EPS)
+                airprime_device.num_ports = NUM_BULK_EPS;
+
         retval = usb_serial_register(&airprime_device);
         if (retval)
                 return retval;
@@ -341,6 +347,7 @@ MODULE_LICENSE("GPL");
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug enabled");
 module_param(buffer_size, int, 0);
-MODULE_PARM_DESC(buffer_size, "Size of the transfer buffers in bytes (default 4096)");
+MODULE_PARM_DESC(buffer_size,
+                "Size of the transfer buffers in bytes (default 4096)");
 module_param(endpoints, int, 0);
 MODULE_PARM_DESC(endpoints, "Number of bulk EPs to configure (default 3)");
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index 599ab2e548a7..77895c8f8f31 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -24,7 +24,7 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include <linux/serial.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 
 static int debug;
@@ -246,29 +246,29 @@ static void ark3116_set_termios(struct usb_serial_port *port,
         baud = tty_get_baud_rate(port->tty);
 
         switch (baud) {
-                case 75:
-                case 150:
-                case 300:
-                case 600:
-                case 1200:
-                case 1800:
-                case 2400:
-                case 4800:
-                case 9600:
-                case 19200:
-                case 38400:
-                case 57600:
-                case 115200:
-                case 230400:
-                case 460800:
-                        /* Report the resulting rate back to the caller */
-                        tty_encode_baud_rate(port->tty, baud, baud);
-                        break;
-                /* set 9600 as default (if given baudrate is invalid for example) */
-                default:
-                        tty_encode_baud_rate(port->tty, 9600, 9600);
-                case 0:
-                        baud = 9600;
+        case 75:
+        case 150:
+        case 300:
+        case 600:
+        case 1200:
+        case 1800:
+        case 2400:
+        case 4800:
+        case 9600:
+        case 19200:
+        case 38400:
+        case 57600:
+        case 115200:
+        case 230400:
+        case 460800:
+                /* Report the resulting rate back to the caller */
+                tty_encode_baud_rate(port->tty, baud, baud);
+                break;
+        /* set 9600 as default (if given baudrate is invalid for example) */
+        default:
+                tty_encode_baud_rate(port->tty, 9600, 9600);
+        case 0:
+                baud = 9600;
         }
 
         /*
@@ -380,19 +380,19 @@ static int ark3116_ioctl(struct usb_serial_port *port, struct file *file,
         switch (cmd) {
         case TIOCGSERIAL:
                 /* XXX: Some of these values are probably wrong. */
-                memset(&serstruct, 0, sizeof (serstruct));
+                memset(&serstruct, 0, sizeof(serstruct));
                 serstruct.type = PORT_16654;
                 serstruct.line = port->serial->minor;
                 serstruct.port = port->number;
                 serstruct.custom_divisor = 0;
                 serstruct.baud_base = 460800;
 
-                if (copy_to_user(user_arg, &serstruct, sizeof (serstruct)))
+                if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
                         return -EFAULT;
 
                 return 0;
         case TIOCSSERIAL:
-                if (copy_from_user(&serstruct, user_arg, sizeof (serstruct)))
+                if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
                         return -EFAULT;
                 return 0;
         default:
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index d947d955bceb..1f7c86bd8297 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -28,6 +28,7 @@ static int debug;
 
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x4348, 0x5523) },
+        { USB_DEVICE(0x1a86, 0x7523) },
         { },
 };
 MODULE_DEVICE_TABLE(usb, id_table);
@@ -130,7 +131,7 @@ static int ch341_get_status(struct usb_device *dev)
                 return -ENOMEM;
 
         r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size);
-        if ( r < 0)
+        if (r < 0)
                 goto out;
 
         /* Not having the datasheet for the CH341, we ignore the bytes returned
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index dc0ea08ed231..f5b57b196c5a 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -73,6 +73,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */
         { USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */
         { USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */
+        { USB_DEVICE(0x10C4, 0x81A6) }, /* ThinkOptics WavIt */
         { USB_DEVICE(0x10C4, 0x81AC) }, /* MSD Dash Hawk */
         { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
         { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index c7329f43d9c9..0ff4a3971e45 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -133,6 +133,14 @@ static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
 static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_0_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_1_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_2_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_3_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_4_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_5_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_6_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_7_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
@@ -166,8 +174,270 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_MTXORB_4_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
-        { USB_DEVICE(MTXORB_VK_VID, MTXORB_VK_PID),
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0100_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0101_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0102_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0103_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0104_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0105_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0106_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0107_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0108_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0109_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_010A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_010B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_010C_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_010D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_010E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_010F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0110_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0111_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0112_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0113_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0114_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0115_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0116_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0117_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0118_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0119_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_011A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_011B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_011C_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_011D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_011E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_011F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0120_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0121_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0122_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0123_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0124_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0125_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0126_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0127_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0128_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0129_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_012A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_012B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_012C_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_012D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_012E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_012F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0130_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0131_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0132_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0133_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0134_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0135_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0136_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0137_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0138_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0139_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_013A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_013B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_013C_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_013D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_013E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_013F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0140_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0141_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0142_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0143_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0144_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0145_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0146_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0147_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0148_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0149_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_014A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_014B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_014C_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_014D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_014E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_014F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0150_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0151_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0152_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0153_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0154_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0155_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0156_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0157_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0158_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0159_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_015A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_015B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_015C_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_015D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_015E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_015F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0160_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0161_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0162_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0163_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0164_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0165_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0166_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0167_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0168_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0169_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_016A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_016B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_016C_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_016D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_016E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_016F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0170_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0171_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0172_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0173_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0174_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0175_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0176_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0177_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0178_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0179_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_017A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_017B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_017C_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_017D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_017E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_017F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0180_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0181_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0182_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0183_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0184_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0185_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0186_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0187_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0188_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0189_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_018A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_018B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_018C_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_018D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_018E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_018F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0190_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0191_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0192_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0193_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0194_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0195_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0196_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0197_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0198_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_0199_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_019A_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_019B_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_019C_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_019D_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_019E_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_019F_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A0_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A1_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A2_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A3_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A4_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A5_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A6_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A7_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A8_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01A9_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01AA_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01AB_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01AC_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01AD_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01AE_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01AF_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B0_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B1_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B2_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B3_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B4_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B5_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B6_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B7_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B8_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01B9_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01BA_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01BB_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01BC_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01BD_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01BE_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01BF_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C0_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C1_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C2_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C3_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C4_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C5_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C6_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C7_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C8_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01C9_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01CA_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01CB_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01CC_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01CD_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01CE_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01CF_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D0_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D1_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D2_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D3_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D4_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D5_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D6_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D7_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D8_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01D9_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01DA_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01DB_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01DC_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01DD_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01DE_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01DF_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E0_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E1_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E2_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E3_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E4_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E5_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E6_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E7_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E8_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01E9_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01EA_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01EB_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01EC_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01ED_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01EE_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01EF_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F0_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F1_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F2_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F3_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F4_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F5_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F6_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F7_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F8_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01F9_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01FA_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01FB_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01FC_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01FD_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01FE_PID) },
+        { USB_DEVICE(MTXORB_VID,MTXORB_FTDI_RANGE_01FF_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
@@ -366,6 +636,8 @@ static struct usb_device_id id_table_combined [] = {
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID),
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
+        { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
+        { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index 6da539ede0ee..8302eca893ea 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -40,6 +40,17 @@
 /* AlphaMicro Components AMC-232USB01 device */
 #define FTDI_AMC232_PID 0xFF00 /* Product Id */
 
+/* SCS HF Radio Modems PID's (http://www.scs-ptc.com) */
+/* the VID is the standard ftdi vid (FTDI_VID) */
+#define FTDI_SCS_DEVICE_0_PID 0xD010    /* SCS PTC-IIusb */
+#define FTDI_SCS_DEVICE_1_PID 0xD011    /* SCS Tracker / DSP TNC */
+#define FTDI_SCS_DEVICE_2_PID 0xD012
+#define FTDI_SCS_DEVICE_3_PID 0xD013
+#define FTDI_SCS_DEVICE_4_PID 0xD014
+#define FTDI_SCS_DEVICE_5_PID 0xD015
+#define FTDI_SCS_DEVICE_6_PID 0xD016
+#define FTDI_SCS_DEVICE_7_PID 0xD017
+
 /* ACT Solutions HomePro ZWave interface (http://www.act-solutions.com/HomePro.htm) */
 #define FTDI_ACTZWAVE_PID       0xF2D0
 
@@ -103,11 +114,268 @@
 #define FTDI_OOCDLINK_PID       0xbaf8  /* Amontec JTAGkey */
 
 /*
- * The following are the values for the Matrix Orbital VK204-25-USB
- * display, which use the FT232RL.
- */
-#define MTXORB_VK_VID           0x1b3d
-#define MTXORB_VK_PID           0x0158
+ * The following are the values for the Matrix Orbital FTDI Range
+ * Anything in this range will use an FT232RL.
+ */
+#define MTXORB_VID                      0x1B3D
+#define MTXORB_FTDI_RANGE_0100_PID      0x0100
+#define MTXORB_FTDI_RANGE_0101_PID      0x0101
+#define MTXORB_FTDI_RANGE_0102_PID      0x0102
+#define MTXORB_FTDI_RANGE_0103_PID      0x0103
+#define MTXORB_FTDI_RANGE_0104_PID      0x0104
+#define MTXORB_FTDI_RANGE_0105_PID      0x0105
+#define MTXORB_FTDI_RANGE_0106_PID      0x0106
+#define MTXORB_FTDI_RANGE_0107_PID      0x0107
+#define MTXORB_FTDI_RANGE_0108_PID      0x0108
+#define MTXORB_FTDI_RANGE_0109_PID      0x0109
+#define MTXORB_FTDI_RANGE_010A_PID      0x010A
+#define MTXORB_FTDI_RANGE_010B_PID      0x010B
+#define MTXORB_FTDI_RANGE_010C_PID      0x010C
+#define MTXORB_FTDI_RANGE_010D_PID      0x010D
+#define MTXORB_FTDI_RANGE_010E_PID      0x010E
+#define MTXORB_FTDI_RANGE_010F_PID      0x010F
+#define MTXORB_FTDI_RANGE_0110_PID      0x0110
+#define MTXORB_FTDI_RANGE_0111_PID      0x0111
+#define MTXORB_FTDI_RANGE_0112_PID      0x0112
+#define MTXORB_FTDI_RANGE_0113_PID      0x0113
+#define MTXORB_FTDI_RANGE_0114_PID      0x0114
+#define MTXORB_FTDI_RANGE_0115_PID      0x0115
+#define MTXORB_FTDI_RANGE_0116_PID      0x0116
+#define MTXORB_FTDI_RANGE_0117_PID      0x0117
+#define MTXORB_FTDI_RANGE_0118_PID      0x0118
+#define MTXORB_FTDI_RANGE_0119_PID      0x0119
+#define MTXORB_FTDI_RANGE_011A_PID      0x011A
+#define MTXORB_FTDI_RANGE_011B_PID      0x011B
+#define MTXORB_FTDI_RANGE_011C_PID      0x011C
+#define MTXORB_FTDI_RANGE_011D_PID      0x011D
+#define MTXORB_FTDI_RANGE_011E_PID      0x011E
+#define MTXORB_FTDI_RANGE_011F_PID      0x011F
+#define MTXORB_FTDI_RANGE_0120_PID      0x0120
+#define MTXORB_FTDI_RANGE_0121_PID      0x0121
+#define MTXORB_FTDI_RANGE_0122_PID      0x0122
+#define MTXORB_FTDI_RANGE_0123_PID      0x0123
+#define MTXORB_FTDI_RANGE_0124_PID      0x0124
+#define MTXORB_FTDI_RANGE_0125_PID      0x0125
+#define MTXORB_FTDI_RANGE_0126_PID      0x0126
+#define MTXORB_FTDI_RANGE_0127_PID      0x0127
+#define MTXORB_FTDI_RANGE_0128_PID      0x0128
+#define MTXORB_FTDI_RANGE_0129_PID      0x0129
+#define MTXORB_FTDI_RANGE_012A_PID      0x012A
+#define MTXORB_FTDI_RANGE_012B_PID      0x012B
+#define MTXORB_FTDI_RANGE_012C_PID      0x012C
+#define MTXORB_FTDI_RANGE_012D_PID      0x012D
+#define MTXORB_FTDI_RANGE_012E_PID      0x012E
+#define MTXORB_FTDI_RANGE_012F_PID      0x012F
+#define MTXORB_FTDI_RANGE_0130_PID      0x0130
+#define MTXORB_FTDI_RANGE_0131_PID      0x0131
+#define MTXORB_FTDI_RANGE_0132_PID      0x0132
+#define MTXORB_FTDI_RANGE_0133_PID      0x0133
+#define MTXORB_FTDI_RANGE_0134_PID      0x0134
+#define MTXORB_FTDI_RANGE_0135_PID      0x0135
+#define MTXORB_FTDI_RANGE_0136_PID      0x0136
+#define MTXORB_FTDI_RANGE_0137_PID      0x0137
+#define MTXORB_FTDI_RANGE_0138_PID      0x0138
+#define MTXORB_FTDI_RANGE_0139_PID      0x0139
+#define MTXORB_FTDI_RANGE_013A_PID      0x013A
+#define MTXORB_FTDI_RANGE_013B_PID      0x013B
+#define MTXORB_FTDI_RANGE_013C_PID      0x013C
+#define MTXORB_FTDI_RANGE_013D_PID      0x013D
+#define MTXORB_FTDI_RANGE_013E_PID      0x013E
+#define MTXORB_FTDI_RANGE_013F_PID      0x013F
+#define MTXORB_FTDI_RANGE_0140_PID      0x0140
+#define MTXORB_FTDI_RANGE_0141_PID      0x0141
+#define MTXORB_FTDI_RANGE_0142_PID      0x0142
+#define MTXORB_FTDI_RANGE_0143_PID      0x0143
+#define MTXORB_FTDI_RANGE_0144_PID      0x0144
+#define MTXORB_FTDI_RANGE_0145_PID      0x0145
+#define MTXORB_FTDI_RANGE_0146_PID      0x0146
+#define MTXORB_FTDI_RANGE_0147_PID      0x0147
+#define MTXORB_FTDI_RANGE_0148_PID      0x0148
+#define MTXORB_FTDI_RANGE_0149_PID      0x0149
+#define MTXORB_FTDI_RANGE_014A_PID      0x014A
+#define MTXORB_FTDI_RANGE_014B_PID      0x014B
+#define MTXORB_FTDI_RANGE_014C_PID      0x014C
+#define MTXORB_FTDI_RANGE_014D_PID      0x014D
+#define MTXORB_FTDI_RANGE_014E_PID      0x014E
+#define MTXORB_FTDI_RANGE_014F_PID      0x014F
+#define MTXORB_FTDI_RANGE_0150_PID      0x0150
+#define MTXORB_FTDI_RANGE_0151_PID      0x0151
+#define MTXORB_FTDI_RANGE_0152_PID      0x0152
+#define MTXORB_FTDI_RANGE_0153_PID      0x0153
+#define MTXORB_FTDI_RANGE_0154_PID      0x0154
+#define MTXORB_FTDI_RANGE_0155_PID      0x0155
+#define MTXORB_FTDI_RANGE_0156_PID      0x0156
+#define MTXORB_FTDI_RANGE_0157_PID      0x0157
+#define MTXORB_FTDI_RANGE_0158_PID      0x0158
+#define MTXORB_FTDI_RANGE_0159_PID      0x0159
+#define MTXORB_FTDI_RANGE_015A_PID      0x015A
+#define MTXORB_FTDI_RANGE_015B_PID      0x015B
+#define MTXORB_FTDI_RANGE_015C_PID      0x015C
+#define MTXORB_FTDI_RANGE_015D_PID      0x015D
+#define MTXORB_FTDI_RANGE_015E_PID      0x015E
+#define MTXORB_FTDI_RANGE_015F_PID      0x015F
+#define MTXORB_FTDI_RANGE_0160_PID      0x0160
+#define MTXORB_FTDI_RANGE_0161_PID      0x0161
+#define MTXORB_FTDI_RANGE_0162_PID      0x0162
+#define MTXORB_FTDI_RANGE_0163_PID      0x0163
+#define MTXORB_FTDI_RANGE_0164_PID      0x0164
+#define MTXORB_FTDI_RANGE_0165_PID      0x0165
+#define MTXORB_FTDI_RANGE_0166_PID      0x0166
+#define MTXORB_FTDI_RANGE_0167_PID      0x0167
+#define MTXORB_FTDI_RANGE_0168_PID      0x0168
+#define MTXORB_FTDI_RANGE_0169_PID      0x0169
+#define MTXORB_FTDI_RANGE_016A_PID      0x016A
+#define MTXORB_FTDI_RANGE_016B_PID      0x016B
+#define MTXORB_FTDI_RANGE_016C_PID      0x016C
+#define MTXORB_FTDI_RANGE_016D_PID      0x016D
+#define MTXORB_FTDI_RANGE_016E_PID      0x016E
+#define MTXORB_FTDI_RANGE_016F_PID      0x016F
+#define MTXORB_FTDI_RANGE_0170_PID      0x0170
+#define MTXORB_FTDI_RANGE_0171_PID      0x0171
+#define MTXORB_FTDI_RANGE_0172_PID      0x0172
+#define MTXORB_FTDI_RANGE_0173_PID      0x0173
+#define MTXORB_FTDI_RANGE_0174_PID      0x0174
+#define MTXORB_FTDI_RANGE_0175_PID      0x0175
+#define MTXORB_FTDI_RANGE_0176_PID      0x0176
+#define MTXORB_FTDI_RANGE_0177_PID      0x0177
+#define MTXORB_FTDI_RANGE_0178_PID      0x0178
+#define MTXORB_FTDI_RANGE_0179_PID      0x0179
+#define MTXORB_FTDI_RANGE_017A_PID      0x017A
+#define MTXORB_FTDI_RANGE_017B_PID      0x017B
+#define MTXORB_FTDI_RANGE_017C_PID      0x017C
+#define MTXORB_FTDI_RANGE_017D_PID      0x017D
+#define MTXORB_FTDI_RANGE_017E_PID      0x017E
+#define MTXORB_FTDI_RANGE_017F_PID      0x017F
+#define MTXORB_FTDI_RANGE_0180_PID      0x0180
+#define MTXORB_FTDI_RANGE_0181_PID      0x0181
+#define MTXORB_FTDI_RANGE_0182_PID      0x0182
+#define MTXORB_FTDI_RANGE_0183_PID      0x0183
+#define MTXORB_FTDI_RANGE_0184_PID      0x0184
+#define MTXORB_FTDI_RANGE_0185_PID      0x0185
+#define MTXORB_FTDI_RANGE_0186_PID      0x0186
+#define MTXORB_FTDI_RANGE_0187_PID      0x0187
+#define MTXORB_FTDI_RANGE_0188_PID      0x0188
+#define MTXORB_FTDI_RANGE_0189_PID      0x0189
+#define MTXORB_FTDI_RANGE_018A_PID      0x018A
+#define MTXORB_FTDI_RANGE_018B_PID      0x018B
+#define MTXORB_FTDI_RANGE_018C_PID      0x018C
+#define MTXORB_FTDI_RANGE_018D_PID      0x018D
+#define MTXORB_FTDI_RANGE_018E_PID      0x018E
+#define MTXORB_FTDI_RANGE_018F_PID      0x018F
+#define MTXORB_FTDI_RANGE_0190_PID      0x0190
+#define MTXORB_FTDI_RANGE_0191_PID      0x0191
+#define MTXORB_FTDI_RANGE_0192_PID      0x0192
+#define MTXORB_FTDI_RANGE_0193_PID      0x0193
+#define MTXORB_FTDI_RANGE_0194_PID      0x0194
+#define MTXORB_FTDI_RANGE_0195_PID      0x0195
+#define MTXORB_FTDI_RANGE_0196_PID      0x0196
+#define MTXORB_FTDI_RANGE_0197_PID      0x0197
+#define MTXORB_FTDI_RANGE_0198_PID      0x0198
+#define MTXORB_FTDI_RANGE_0199_PID      0x0199
+#define MTXORB_FTDI_RANGE_019A_PID      0x019A
+#define MTXORB_FTDI_RANGE_019B_PID      0x019B
+#define MTXORB_FTDI_RANGE_019C_PID      0x019C
+#define MTXORB_FTDI_RANGE_019D_PID      0x019D
+#define MTXORB_FTDI_RANGE_019E_PID      0x019E
+#define MTXORB_FTDI_RANGE_019F_PID      0x019F
+#define MTXORB_FTDI_RANGE_01A0_PID      0x01A0
+#define MTXORB_FTDI_RANGE_01A1_PID      0x01A1
+#define MTXORB_FTDI_RANGE_01A2_PID      0x01A2
+#define MTXORB_FTDI_RANGE_01A3_PID      0x01A3
+#define MTXORB_FTDI_RANGE_01A4_PID      0x01A4
+#define MTXORB_FTDI_RANGE_01A5_PID      0x01A5
+#define MTXORB_FTDI_RANGE_01A6_PID      0x01A6
+#define MTXORB_FTDI_RANGE_01A7_PID      0x01A7
+#define MTXORB_FTDI_RANGE_01A8_PID      0x01A8
+#define MTXORB_FTDI_RANGE_01A9_PID      0x01A9
+#define MTXORB_FTDI_RANGE_01AA_PID      0x01AA
+#define MTXORB_FTDI_RANGE_01AB_PID      0x01AB
+#define MTXORB_FTDI_RANGE_01AC_PID      0x01AC
+#define MTXORB_FTDI_RANGE_01AD_PID      0x01AD
+#define MTXORB_FTDI_RANGE_01AE_PID      0x01AE
+#define MTXORB_FTDI_RANGE_01AF_PID      0x01AF
+#define MTXORB_FTDI_RANGE_01B0_PID      0x01B0
+#define MTXORB_FTDI_RANGE_01B1_PID      0x01B1
+#define MTXORB_FTDI_RANGE_01B2_PID      0x01B2
+#define MTXORB_FTDI_RANGE_01B3_PID      0x01B3
+#define MTXORB_FTDI_RANGE_01B4_PID      0x01B4
+#define MTXORB_FTDI_RANGE_01B5_PID      0x01B5
+#define MTXORB_FTDI_RANGE_01B6_PID      0x01B6
+#define MTXORB_FTDI_RANGE_01B7_PID      0x01B7
+#define MTXORB_FTDI_RANGE_01B8_PID      0x01B8
+#define MTXORB_FTDI_RANGE_01B9_PID      0x01B9
+#define MTXORB_FTDI_RANGE_01BA_PID      0x01BA
+#define MTXORB_FTDI_RANGE_01BB_PID      0x01BB
+#define MTXORB_FTDI_RANGE_01BC_PID      0x01BC
+#define MTXORB_FTDI_RANGE_01BD_PID      0x01BD
+#define MTXORB_FTDI_RANGE_01BE_PID      0x01BE
+#define MTXORB_FTDI_RANGE_01BF_PID      0x01BF
+#define MTXORB_FTDI_RANGE_01C0_PID      0x01C0
+#define MTXORB_FTDI_RANGE_01C1_PID      0x01C1
+#define MTXORB_FTDI_RANGE_01C2_PID      0x01C2
+#define MTXORB_FTDI_RANGE_01C3_PID      0x01C3
+#define MTXORB_FTDI_RANGE_01C4_PID      0x01C4
+#define MTXORB_FTDI_RANGE_01C5_PID      0x01C5
+#define MTXORB_FTDI_RANGE_01C6_PID      0x01C6
+#define MTXORB_FTDI_RANGE_01C7_PID      0x01C7
+#define MTXORB_FTDI_RANGE_01C8_PID      0x01C8
+#define MTXORB_FTDI_RANGE_01C9_PID      0x01C9
+#define MTXORB_FTDI_RANGE_01CA_PID      0x01CA
+#define MTXORB_FTDI_RANGE_01CB_PID      0x01CB
+#define MTXORB_FTDI_RANGE_01CC_PID      0x01CC
+#define MTXORB_FTDI_RANGE_01CD_PID      0x01CD
+#define MTXORB_FTDI_RANGE_01CE_PID      0x01CE
+#define MTXORB_FTDI_RANGE_01CF_PID      0x01CF
+#define MTXORB_FTDI_RANGE_01D0_PID      0x01D0
+#define MTXORB_FTDI_RANGE_01D1_PID      0x01D1
+#define MTXORB_FTDI_RANGE_01D2_PID      0x01D2
+#define MTXORB_FTDI_RANGE_01D3_PID      0x01D3
+#define MTXORB_FTDI_RANGE_01D4_PID      0x01D4
+#define MTXORB_FTDI_RANGE_01D5_PID      0x01D5
+#define MTXORB_FTDI_RANGE_01D6_PID      0x01D6
+#define MTXORB_FTDI_RANGE_01D7_PID      0x01D7
+#define MTXORB_FTDI_RANGE_01D8_PID      0x01D8
+#define MTXORB_FTDI_RANGE_01D9_PID      0x01D9
+#define MTXORB_FTDI_RANGE_01DA_PID      0x01DA
+#define MTXORB_FTDI_RANGE_01DB_PID      0x01DB
+#define MTXORB_FTDI_RANGE_01DC_PID      0x01DC
+#define MTXORB_FTDI_RANGE_01DD_PID      0x01DD
+#define MTXORB_FTDI_RANGE_01DE_PID      0x01DE
+#define MTXORB_FTDI_RANGE_01DF_PID      0x01DF
+#define MTXORB_FTDI_RANGE_01E0_PID      0x01E0
+#define MTXORB_FTDI_RANGE_01E1_PID      0x01E1
+#define MTXORB_FTDI_RANGE_01E2_PID      0x01E2
+#define MTXORB_FTDI_RANGE_01E3_PID      0x01E3
+#define MTXORB_FTDI_RANGE_01E4_PID      0x01E4
+#define MTXORB_FTDI_RANGE_01E5_PID      0x01E5
+#define MTXORB_FTDI_RANGE_01E6_PID      0x01E6
+#define MTXORB_FTDI_RANGE_01E7_PID      0x01E7
+#define MTXORB_FTDI_RANGE_01E8_PID      0x01E8
+#define MTXORB_FTDI_RANGE_01E9_PID      0x01E9
+#define MTXORB_FTDI_RANGE_01EA_PID      0x01EA
+#define MTXORB_FTDI_RANGE_01EB_PID      0x01EB
+#define MTXORB_FTDI_RANGE_01EC_PID      0x01EC
+#define MTXORB_FTDI_RANGE_01ED_PID      0x01ED
+#define MTXORB_FTDI_RANGE_01EE_PID      0x01EE
+#define MTXORB_FTDI_RANGE_01EF_PID      0x01EF
+#define MTXORB_FTDI_RANGE_01F0_PID      0x01F0
+#define MTXORB_FTDI_RANGE_01F1_PID      0x01F1
+#define MTXORB_FTDI_RANGE_01F2_PID      0x01F2
+#define MTXORB_FTDI_RANGE_01F3_PID      0x01F3
+#define MTXORB_FTDI_RANGE_01F4_PID      0x01F4
+#define MTXORB_FTDI_RANGE_01F5_PID      0x01F5
+#define MTXORB_FTDI_RANGE_01F6_PID      0x01F6
+#define MTXORB_FTDI_RANGE_01F7_PID      0x01F7
+#define MTXORB_FTDI_RANGE_01F8_PID      0x01F8
+#define MTXORB_FTDI_RANGE_01F9_PID      0x01F9
+#define MTXORB_FTDI_RANGE_01FA_PID      0x01FA
+#define MTXORB_FTDI_RANGE_01FB_PID      0x01FB
+#define MTXORB_FTDI_RANGE_01FC_PID      0x01FC
+#define MTXORB_FTDI_RANGE_01FD_PID      0x01FD
+#define MTXORB_FTDI_RANGE_01FE_PID      0x01FE
+#define MTXORB_FTDI_RANGE_01FF_PID      0x01FF
+
+
 
 /* Interbiometrics USB I/O Board */
 /* Developed for Interbiometrics by Rudolf Gugler */
@@ -560,6 +828,9 @@
 /* Propox devices */
 #define FTDI_PROPOX_JTAGCABLEII_PID     0xD738
 
+/* Rig Expert Ukraine devices */
+#define FTDI_REU_TINY_PID               0xED22  /* RigExpert Tiny */
+
 /* Commands */
 #define FTDI_SIO_RESET          0 /* Reset the port */
 #define FTDI_SIO_MODEM_CTRL     1 /* Set the modem control register */
@@ -581,6 +852,12 @@
 #define FIC_NEO1973_DEBUG_PID   0x5118
 
 /*
+ * RATOC REX-USB60F
+ */
+#define RATOC_VENDOR_ID         0x0584
+#define RATOC_PRODUCT_ID_USB60F 0xb020
+
+/*
  *   BmRequestType:  1100 0000b
  *   bRequest:       FTDI_E2_READ
  *   wValue:         0
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index ea924dc48496..d9fb3768a2d7 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -570,7 +570,12 @@ static struct usb_serial_driver ipaq_device = {
         .description =          "PocketPC PDA",
         .usb_driver =           &ipaq_driver,
         .id_table =             ipaq_id_table,
-        .num_ports =            2,
+        /*
+         * some devices have an extra endpoint, which
+         * must be ignored as it would make the core
+         * create a second port which oopses when used
+         */
+        .num_ports =            1,
         .open =                 ipaq_open,
         .close =                ipaq_close,
         .attach =               ipaq_startup,
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index 8a217648b250..a01e987c7d32 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -643,7 +643,7 @@ static void read_buf_callback(struct urb *urb)
 static int iuu_bulk_write(struct usb_serial_port *port)
 {
         struct iuu_private *priv = usb_get_serial_port_data(port);
-        unsigned int flags;
+        unsigned long flags;
         int result;
         int i;
         char *buf_ptr = port->write_urb->transfer_buffer;
@@ -694,7 +694,7 @@ static void iuu_uart_read_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct iuu_private *priv = usb_get_serial_port_data(port);
-        unsigned int flags;
+        unsigned long flags;
         int status;
         int error = 0;
         int len = 0;
@@ -759,7 +759,7 @@ static int iuu_uart_write(struct usb_serial_port *port, const u8 *buf,
                           int count)
 {
         struct iuu_private *priv = usb_get_serial_port_data(port);
-        unsigned int flags;
+        unsigned long flags;
         dbg("%s - enter", __func__);
 
         if (count > 256)
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 6bcb82d3911a..78f2f6db494d 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -1713,7 +1713,7 @@ static int mos7840_tiocmset(struct usb_serial_port *port, struct file *file,
 {
         struct moschip_port *mos7840_port;
         unsigned int mcr;
-        unsigned int status;
+        int status;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -1740,11 +1740,10 @@ static int mos7840_tiocmset(struct usb_serial_port *port, struct file *file,
 
         mos7840_port->shadowMCR = mcr;
 
-        status = 0;
         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr);
         if (status < 0) {
                 dbg("setting MODEM_CONTROL_REGISTER Failed\n");
-                return -1;
+                return status;
         }
 
         return 0;
diff --git a/drivers/usb/serial/moto_modem.c b/drivers/usb/serial/moto_modem.c
new file mode 100644
index 000000000000..2e8e05462ef7
--- /dev/null
+++ b/drivers/usb/serial/moto_modem.c
@@ -0,0 +1,70 @@
+/*
+ * Motorola USB Phone driver
+ *
+ * Copyright (C) 2008 Greg Kroah-Hartman <greg@kroah.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ * {sigh}
+ * Mororola 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/tty.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb/serial.h>
+
+static struct usb_device_id id_table [] = {
+        { USB_DEVICE(0x05c6, 0x3197) }, /* unknown Motorola phone */
+        { USB_DEVICE(0x0c44, 0x0022) }, /* unknown Mororola phone */
+        { USB_DEVICE(0x22b8, 0x2a64) }, /* Motorola KRZR K1m */
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+static struct usb_driver moto_driver = {
+        .name =         "moto-modem",
+        .probe =        usb_serial_probe,
+        .disconnect =   usb_serial_disconnect,
+        .id_table =     id_table,
+        .no_dynamic_id =        1,
+};
+
+static struct usb_serial_driver moto_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "moto-modem",
+        },
+        .id_table =             id_table,
+        .num_ports =            1,
+};
+
+static int __init moto_init(void)
+{
+        int retval;
+
+        retval = usb_serial_register(&moto_device);
+        if (retval)
+                return retval;
+        retval = usb_register(&moto_driver);
+        if (retval)
+                usb_serial_deregister(&moto_device);
+        return retval;
+}
+
+static void __exit moto_exit(void)
+{
+        usb_deregister(&moto_driver);
+        usb_serial_deregister(&moto_device);
+}
+
+module_init(moto_init);
+module_exit(moto_exit);
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index e4be2d442b1e..a73420dd052a 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -154,8 +154,6 @@ static int  option_send_setup(struct usb_serial_port *port);
 #define NOVATELWIRELESS_PRODUCT_MC727           0x4100
 #define NOVATELWIRELESS_PRODUCT_MC950D          0x4400
 
-#define NOVATELWIRELESS_PRODUCT_U727            0x5010
-
 /* FUTURE NOVATEL PRODUCTS */
 #define NOVATELWIRELESS_PRODUCT_EVDO_1          0x6000
 #define NOVATELWIRELESS_PRODUCT_HSPA_1          0x7000
@@ -184,6 +182,10 @@ static int  option_send_setup(struct usb_serial_port *port);
 #define AXESSTEL_VENDOR_ID                      0x1726
 #define AXESSTEL_PRODUCT_MV110H                 0x1000
 
+#define ONDA_VENDOR_ID                          0x19d2
+#define ONDA_PRODUCT_MSA501HS                   0x0001
+#define ONDA_PRODUCT_ET502HS                    0x0002
+
 #define BANDRICH_VENDOR_ID                      0x1A8D
 #define BANDRICH_PRODUCT_C100_1                 0x1002
 #define BANDRICH_PRODUCT_C100_2                 0x1003
@@ -195,6 +197,9 @@ static int  option_send_setup(struct usb_serial_port *port);
 
 #define MAXON_VENDOR_ID                         0x16d8
 
+#define TELIT_VENDOR_ID                         0x1bc7
+#define TELIT_PRODUCT_UC864E                    0x1003
+
 static struct usb_device_id option_ids[] = {
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
@@ -231,25 +236,25 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_NETWORK_EX) },
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_MODEM) },
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_ETNA_KOI_NETWORK) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E220BIS, 0xff, 0xff, 0xff) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1401) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1403) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1405) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1406) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1408) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1409) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1410) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1411) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1412) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1413) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1414) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1415) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1416) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1417) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1418) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1419) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1401, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1403, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1405, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1406, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1408, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1409, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1410, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1411, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1412, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1413, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1414, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1415, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1416, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1417, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1418, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1419, 0xff, 0xff, 0xff) },
         { USB_DEVICE(AMOI_VENDOR_ID, AMOI_PRODUCT_9508) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) }, /* Novatel Merlin V640/XV620 */
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) }, /* Novatel Merlin V620/S620 */
@@ -269,7 +274,6 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EU870D) }, /* Novatel EU850D/EU860D/EU870D */
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC950D) }, /* Novatel MC930D/MC950D */
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC727) }, /* Novatel MC727/U727/USB727 */
-        { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_U727) }, /* Novatel U727 */
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EVDO_1) }, /* Novatel EVDO product */
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_HSPA_1) }, /* Novatel HSPA product */
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_EMBEDDED_1) }, /* Novatel Embedded product */
@@ -293,14 +297,19 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(DELL_VENDOR_ID, 0x8133) }, /* Dell Wireless 5720 == Novatel EV620 CDMA/EV-DO */
         { USB_DEVICE(DELL_VENDOR_ID, 0x8136) }, /* Dell Wireless HSDPA 5520 == Novatel Expedite EU860D */
         { USB_DEVICE(DELL_VENDOR_ID, 0x8137) }, /* Dell Wireless HSDPA 5520 */
+        { USB_DEVICE(DELL_VENDOR_ID, 0x8138) }, /* Dell Wireless 5520 Voda I Mobile Broadband (3G HSDPA) Minicard */
         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_E100A) },
         { USB_DEVICE(ANYDATA_VENDOR_ID, ANYDATA_PRODUCT_ADU_500A) },
         { USB_DEVICE(AXESSTEL_VENDOR_ID, AXESSTEL_PRODUCT_MV110H) },
+        { USB_DEVICE(ONDA_VENDOR_ID, ONDA_PRODUCT_MSA501HS) },
+        { USB_DEVICE(ONDA_VENDOR_ID, ONDA_PRODUCT_ET502HS) },
         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },
         { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC680) },
+        { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6000)}, /* ZTE AC8700 */
         { 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) },
         { } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index c605fb68f807..2a0dd1b50dc4 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -56,6 +56,8 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
+        { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
+        { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
         { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
@@ -66,7 +68,6 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
         { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
-        { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
         { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
         { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
         { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index 10cf872e5ecb..6ac3bbcf7a22 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -14,6 +14,8 @@
 #define PL2303_PRODUCT_ID_PHAROS        0xaaa0
 #define PL2303_PRODUCT_ID_RSAQ3         0xaaa2
 #define PL2303_PRODUCT_ID_ALDIGA        0x0611
+#define PL2303_PRODUCT_ID_MMX           0x0612
+#define PL2303_PRODUCT_ID_GPRS          0x0609
 
 #define ATEN_VENDOR_ID          0x0557
 #define ATEN_VENDOR_ID2         0x0547
@@ -36,7 +38,6 @@
 
 #define RATOC_VENDOR_ID         0x0584
 #define RATOC_PRODUCT_ID        0xb000
-#define RATOC_PRODUCT_ID_USB60F 0xb020
 
 #define TRIPP_VENDOR_ID         0x2478
 #define TRIPP_PRODUCT_ID        0x2008
diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index 0f6d234d699b..3d9249632ae1 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -123,7 +123,8 @@ config USB_STORAGE_ALAUDA
 
 config USB_STORAGE_ONETOUCH
         bool "Support OneTouch Button on Maxtor Hard Drives"
-        depends on USB_STORAGE && INPUT_EVDEV
+        depends on USB_STORAGE
+        depends on INPUT=y || INPUT=USB_STORAGE
         help
           Say Y here to include additional code to support the Maxtor OneTouch
           USB hard drive's onetouch button.
diff --git a/drivers/usb/storage/cypress_atacb.c b/drivers/usb/storage/cypress_atacb.c
index d88824b3511c..898e67d30e56 100644
--- a/drivers/usb/storage/cypress_atacb.c
+++ b/drivers/usb/storage/cypress_atacb.c
@@ -46,7 +46,7 @@ void cypress_atacb_passthrough(struct scsi_cmnd *srb, struct us_data *us)
         }
 
         memcpy(save_cmnd, srb->cmnd, sizeof(save_cmnd));
-        memset(srb->cmnd, 0, sizeof(srb->cmnd));
+        memset(srb->cmnd, 0, MAX_COMMAND_SIZE);
 
         /* check if we support the command */
         if (save_cmnd[1] >> 5) /* MULTIPLE_COUNT */
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 971d13dd5e65..3addcd8f827b 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -292,6 +292,7 @@ struct isd200_info {
 
         /* maximum number of LUNs supported */
         unsigned char MaxLUNs;
+        unsigned char cmnd[BLK_MAX_CDB];
         struct scsi_cmnd srb;
         struct scatterlist sg;
 };
@@ -450,6 +451,7 @@ static int isd200_action( struct us_data *us, int action,
 
         memset(&ata, 0, sizeof(ata));
         memset(&srb_dev, 0, sizeof(srb_dev));
+        srb->cmnd = info->cmnd;
         srb->device = &srb_dev;
         ++srb->serial_number;
 
diff --git a/drivers/usb/storage/libusual.c b/drivers/usb/storage/libusual.c
index a28d49122e7a..d617e8ae6b00 100644
--- a/drivers/usb/storage/libusual.c
+++ b/drivers/usb/storage/libusual.c
@@ -135,7 +135,7 @@ static int usu_probe(struct usb_interface *intf,
         stat[type].fls |= USU_MOD_FL_THREAD;
         spin_unlock_irqrestore(&usu_lock, flags);
 
-        task = kthread_run(usu_probe_thread, (void*)type, "libusual_%d", type);
+        task = kthread_run(usu_probe_thread, (void*)type, "libusual_%ld", type);
         if (IS_ERR(task)) {
                 rc = PTR_ERR(task);
                 printk(KERN_WARNING "libusual: "
diff --git a/drivers/usb/storage/onetouch.c b/drivers/usb/storage/onetouch.c
index dfd42fe9e5f0..98b89ea9e312 100644
--- a/drivers/usb/storage/onetouch.c
+++ b/drivers/usb/storage/onetouch.c
@@ -38,7 +38,7 @@
 #include "onetouch.h"
 #include "debug.h"
 
-void onetouch_release_input(void *onetouch_);
+static void onetouch_release_input(void *onetouch_);
 
 struct usb_onetouch {
         char name[128];
@@ -223,7 +223,7 @@ int onetouch_connect_input(struct us_data *ss)
         return error;
 }
 
-void onetouch_release_input(void *onetouch_)
+static void onetouch_release_input(void *onetouch_)
 {
         struct usb_onetouch *onetouch = (struct usb_onetouch *) onetouch_;
 
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 732bf52a775e..39a7c11795c4 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -44,7 +44,8 @@
  *        running with this patch.
  * Send your submission to either Phil Dibowitz <phil@ipom.com> or
  * Alan Stern <stern@rowland.harvard.edu>, and don't forget to CC: the
- * USB development list <linux-usb-devel@lists.sourceforge.net>.
+ * USB development list <linux-usb@vger.kernel.org> and the USB storage list
+ * <usb-storage@lists.one-eyed-alien.net>
  */
 
 /* patch submitted by Vivian Bregier <Vivian.Bregier@imag.fr>
@@ -400,6 +401,22 @@ UNUSUAL_DEV(  0x04a5, 0x3010, 0x0100, 0x0100,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
+#ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
+/* CY7C68300 : support atacb */
+UNUSUAL_DEV(  0x04b4, 0x6830, 0x0000, 0x9999,
+                "Cypress",
+                "Cypress AT2LP",
+                US_SC_CYP_ATACB, US_PR_DEVICE, NULL,
+                0),
+
+/* CY7C68310 : support atacb and atacb2 */
+UNUSUAL_DEV(  0x04b4, 0x6831, 0x0000, 0x9999,
+                "Cypress",
+                "Cypress ISD-300LP",
+                US_SC_CYP_ATACB, US_PR_DEVICE, NULL,
+                0),
+#endif
+
 /* Reported by Simon Levitt <simon@whattf.com>
  * This entry needs Sub and Proto fields */
 UNUSUAL_DEV(  0x04b8, 0x0601, 0x0100, 0x0100,
@@ -538,25 +555,31 @@ UNUSUAL_DEV(  0x04e6, 0x0101, 0x0200, 0x0200,
                 "CD-RW Device",
                 US_SC_8020, US_PR_CB, NULL, 0),
 
+#ifdef CONFIG_USB_STORAGE_USBAT
+UNUSUAL_DEV(  0x04e6, 0x1010, 0x0000, 0x9999,
+                "Shuttle/SCM",
+                "USBAT-02",
+                US_SC_SCSI, US_PR_USBAT, init_usbat_flash,
+                US_FL_SINGLE_LUN),
+#endif
+
+/* Reported by Dmitry Khlystov <adminimus@gmail.com> */
+UNUSUAL_DEV(  0x04e8, 0x507c, 0x0220, 0x0220,
+                "Samsung",
+                "YP-U3",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_MAX_SECTORS_64),
+
 /* Entry and supporting patch by Theodore Kilgore <kilgota@auburn.edu>.
  * Device uses standards-violating 32-byte Bulk Command Block Wrappers and
  * reports itself as "Proprietary SCSI Bulk." Cf. device entry 0x084d:0x0011.
  */
-
 UNUSUAL_DEV(  0x04fc, 0x80c2, 0x0100, 0x0100,
                 "Kobian Mercury",
                 "Binocam DCB-132",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_BULK32),
 
-#ifdef CONFIG_USB_STORAGE_USBAT
-UNUSUAL_DEV(  0x04e6, 0x1010, 0x0000, 0x9999,
-                "Shuttle/SCM",
-                "USBAT-02",
-                US_SC_SCSI, US_PR_USBAT, init_usbat_flash,
-                US_FL_SINGLE_LUN),
-#endif
-
 /* Reported by Bob Sass <rls@vectordb.com> -- only rev 1.33 tested */
 UNUSUAL_DEV(  0x050d, 0x0115, 0x0133, 0x0133,
                 "Belkin",
@@ -1200,6 +1223,17 @@ UNUSUAL_DEV(  0x084d, 0x0011, 0x0110, 0x0110,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_BULK32),
 
+/* Andrew Lunn <andrew@lunn.ch>
+ * PanDigital Digital Picture Frame. Does not like ALLOW_MEDIUM_REMOVAL
+ * on LUN 4.
+ * Note: Vend:Prod clash with "Ltd Maxell WS30 Slim Digital Camera"
+*/
+UNUSUAL_DEV(  0x0851, 0x1543, 0x0200, 0x0200,
+                "PanDigital",
+                "Photo Frame",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_NOT_LOCKABLE),
+
 /* Submitted by Jan De Luyck <lkml@kcore.org> */
 UNUSUAL_DEV(  0x08bd, 0x1100, 0x0000, 0x0000,
                 "CITIZEN",
@@ -1285,6 +1319,16 @@ UNUSUAL_DEV( 0x0ace, 0x20ff, 0x0101, 0x0101,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_IGNORE_DEVICE ),
 
+/* Reported by F. Aben <f.aben@option.com>
+ * This device (wrongly) has a vendor-specific device descriptor.
+ * The entry is needed so usb-storage can bind to it's mass-storage
+ * interface as an interface driver */
+UNUSUAL_DEV( 0x0af0, 0x7401, 0x0000, 0x0000,
+                "Option",
+                "GI 0401 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
 #ifdef CONFIG_USB_STORAGE_ISD200
 UNUSUAL_DEV(  0x0bf6, 0xa001, 0x0100, 0x0110,
                 "ATI",
@@ -1486,7 +1530,7 @@ UNUSUAL_DEV(  0x0fce, 0xe031, 0x0000, 0x0000,
                 "Sony Ericsson",
                 "M600i",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY ),
+                US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
 
 /* Reported by Kevin Cernekee <kpc-usbdev@gelato.uiuc.edu>
  * Tested on hardware version 1.10.
@@ -1658,6 +1702,16 @@ UNUSUAL_DEV(  0x1652, 0x6600, 0x0201, 0x0201,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
+/* Reported by Mauro Andreolini <andreoli@weblab.ing.unimo.it>
+ * This entry is needed to bypass the ZeroCD mechanism
+ * and to properly load as a modem device.
+ */
+UNUSUAL_DEV(  0x19d2, 0x2000, 0x0000, 0x0000,
+                "Onda ET502HS",
+                "USB MMC Storage",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_IGNORE_DEVICE),
+
 /* patch submitted by Davide Perini <perini.davide@dpsoftware.org>
  * and Renato Perini <rperini@email.it>
  */
@@ -1670,10 +1724,12 @@ UNUSUAL_DEV(  0x22b8, 0x3010, 0x0001, 0x0001,
 /*
  * Patch by Pete Zaitcev <zaitcev@redhat.com>
  * Report by Mark Patton. Red Hat bz#208928.
+ * Added support for rev 0x0002 (Motorola ROKR W5)
+ * by Javier Smaldone <javier@smaldone.com.ar>
  */
-UNUSUAL_DEV(  0x22b8, 0x4810, 0x0001, 0x0001,
+UNUSUAL_DEV(  0x22b8, 0x4810, 0x0001, 0x0002,
                 "Motorola",
-                "RAZR V3i",
+                "RAZR V3i/ROKR W5",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
@@ -1695,6 +1751,13 @@ UNUSUAL_DEV(  0x2735, 0x100b, 0x0000, 0x9999,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_GO_SLOW ),
 
+/* Reported by Rohan Hart <rohan.hart17@gmail.com> */
+UNUSUAL_DEV(  0x2770, 0x915d, 0x0010, 0x0010,
+                "INTOVA",
+                "Pixtreme",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY ),
+
 /*
  * David Härdeman <david@2gen.com>
  * The key makes the SCSI stack print confusing (but harmless) messages
@@ -1719,14 +1782,6 @@ UNUSUAL_DEV(  0xed06, 0x4500, 0x0001, 0x0001,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_CAPACITY_HEURISTICS),
 
-#ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
-UNUSUAL_DEV(  0x04b4, 0x6830, 0x0000, 0x9999,
-                "Cypress",
-                "Cypress AT2LP",
-                US_SC_CYP_ATACB, US_PR_BULK, NULL,
-                0),
-#endif
-
 /* Control/Bulk transport for all SubClass values */
 USUAL_DEV(US_SC_RBC, US_PR_CB, USB_US_TYPE_STOR),
 USUAL_DEV(US_SC_8020, US_PR_CB, USB_US_TYPE_STOR),
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index a856effad3bd..e268aacb773a 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -539,7 +539,8 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id)
                                 " has %s in unusual_devs.h (kernel"
                                 " %s)\n"
                                 "   Please send a copy of this message to "
-                                "<linux-usb-devel@lists.sourceforge.net>\n",
+                                "<linux-usb@vger.kernel.org> and "
+                                "<usb-storage@lists.one-eyed-alien.net>\n",
                                 le16_to_cpu(ddesc->idVendor),
                                 le16_to_cpu(ddesc->idProduct),
                                 le16_to_cpu(ddesc->bcdDevice),