295 files changed, 18743 insertions, 6657 deletions

diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 240750881d28..6a58cb1330c1 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -21,6 +21,7 @@ config USB_ARCH_HAS_HCD
         default y if USB_ARCH_HAS_EHCI
         default y if PCMCIA && !M32R                    # sl811_cs
         default y if ARM                                # SL-811
+        default y if BLACKFIN                           # SL-811
         default y if SUPERH                             # r8a66597-hcd
         default PCI
 
@@ -39,6 +40,7 @@ config USB_ARCH_HAS_OHCI
         default y if ARCH_PNX4008 && I2C
         default y if MFD_TC6393XB
         default y if ARCH_W90X900
+        default y if ARCH_DAVINCI_DA8XX
         # PPC:
         default y if STB03xxx
         default y if PPC_MPC52xx
@@ -60,6 +62,8 @@ config USB_ARCH_HAS_EHCI
         default y if ARCH_IXP4XX
         default y if ARCH_W90X900
         default y if ARCH_AT91SAM9G45
+        default y if ARCH_MXC
+        default y if ARCH_OMAP3
         default PCI
 
 # ARM SA1111 chips have a non-PCI based "OHCI-compatible" USB host interface.
diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index be3c9b80bc9f..80b4008c89ba 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_USB_U132_HCD)	+= host/
 obj-$(CONFIG_USB_R8A66597_HCD)  += host/
 obj-$(CONFIG_USB_HWA_HCD)       += host/
 obj-$(CONFIG_USB_ISP1760_HCD)   += host/
+obj-$(CONFIG_USB_IMX21_HCD)     += host/
 
 obj-$(CONFIG_USB_C67X00_HCD)    += c67x00/
 
diff --git a/drivers/usb/atm/cxacru.c b/drivers/usb/atm/cxacru.c
index 56802d2e994b..c89990f5e018 100644
--- a/drivers/usb/atm/cxacru.c
+++ b/drivers/usb/atm/cxacru.c
@@ -5,6 +5,7 @@
  *  Copyright (C) 2004 David Woodhouse, Duncan Sands, Roman Kagan
  *  Copyright (C) 2005 Duncan Sands, Roman Kagan (rkagan % mail ! ru)
  *  Copyright (C) 2007 Simon Arlott
+ *  Copyright (C) 2009 Simon Arlott
  *
  *  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
@@ -43,7 +44,7 @@
 #include "usbatm.h"
 
 #define DRIVER_AUTHOR   "Roman Kagan, David Woodhouse, Duncan Sands, Simon Arlott"
-#define DRIVER_VERSION  "0.3"
+#define DRIVER_VERSION  "0.4"
 #define DRIVER_DESC     "Conexant AccessRunner ADSL USB modem driver"
 
 static const char cxacru_driver_name[] = "cxacru";
@@ -52,6 +53,7 @@ static const char cxacru_driver_name[] = "cxacru";
 #define CXACRU_EP_DATA          0x02    /* Bulk in/out */
 
 #define CMD_PACKET_SIZE         64      /* Should be maxpacket(ep)? */
+#define CMD_MAX_CONFIG          ((CMD_PACKET_SIZE / 4 - 1) / 2)
 
 /* Addresses */
 #define PLLFCLK_ADDR    0x00350068
@@ -105,6 +107,26 @@ enum cxacru_cm_request {
         CM_REQUEST_MAX,
 };
 
+/* commands for interaction with the flash memory
+ *
+ * read:  response is the contents of the first 60 bytes of flash memory
+ * write: request contains the 60 bytes of data to write to flash memory
+ *        response is the contents of the first 60 bytes of flash memory
+ *
+ * layout: PP PP VV VV  MM MM MM MM  MM MM ?? ??  SS SS SS SS  SS SS SS SS
+ *         SS SS SS SS  SS SS SS SS  00 00 00 00  00 00 00 00  00 00 00 00
+ *         00 00 00 00  00 00 00 00  00 00 00 00  00 00 00 00  00 00 00 00
+ *
+ *   P: le16  USB Product ID
+ *   V: le16  USB Vendor ID
+ *   M: be48  MAC Address
+ *   S: le16  ASCII Serial Number
+ */
+enum cxacru_cm_flash {
+        CM_FLASH_READ = 0xa1,
+        CM_FLASH_WRITE = 0xa2
+};
+
 /* reply codes to the commands above */
 enum cxacru_cm_status {
         CM_STATUS_UNDEFINED,
@@ -196,23 +218,32 @@ static DEVICE_ATTR(_name, S_IRUGO, cxacru_sysfs_show_##_name, NULL)
 static DEVICE_ATTR(_name, S_IWUSR | S_IRUGO, \
         cxacru_sysfs_show_##_name, cxacru_sysfs_store_##_name)
 
+#define CXACRU_SET_INIT(_name) \
+static DEVICE_ATTR(_name, S_IWUSR, \
+        NULL, cxacru_sysfs_store_##_name)
+
 #define CXACRU_ATTR_INIT(_value, _type, _name) \
 static ssize_t cxacru_sysfs_show_##_name(struct device *dev, \
         struct device_attribute *attr, char *buf) \
 { \
-        struct usb_interface *intf = to_usb_interface(dev); \
-        struct usbatm_data *usbatm_instance = usb_get_intfdata(intf); \
-        struct cxacru_data *instance = usbatm_instance->driver_data; \
+        struct cxacru_data *instance = to_usbatm_driver_data(\
+                to_usb_interface(dev)); \
+\
+        if (instance == NULL) \
+                return -ENODEV; \
+\
         return cxacru_sysfs_showattr_##_type(instance->card_info[_value], buf); \
 } \
 CXACRU__ATTR_INIT(_name)
 
 #define CXACRU_ATTR_CREATE(_v, _t, _name) CXACRU_DEVICE_CREATE_FILE(_name)
 #define CXACRU_CMD_CREATE(_name)          CXACRU_DEVICE_CREATE_FILE(_name)
+#define CXACRU_SET_CREATE(_name)          CXACRU_DEVICE_CREATE_FILE(_name)
 #define CXACRU__ATTR_CREATE(_name)        CXACRU_DEVICE_CREATE_FILE(_name)
 
 #define CXACRU_ATTR_REMOVE(_v, _t, _name) CXACRU_DEVICE_REMOVE_FILE(_name)
 #define CXACRU_CMD_REMOVE(_name)          CXACRU_DEVICE_REMOVE_FILE(_name)
+#define CXACRU_SET_REMOVE(_name)          CXACRU_DEVICE_REMOVE_FILE(_name)
 #define CXACRU__ATTR_REMOVE(_name)        CXACRU_DEVICE_REMOVE_FILE(_name)
 
 static ssize_t cxacru_sysfs_showattr_u32(u32 value, char *buf)
@@ -267,12 +298,12 @@ static ssize_t cxacru_sysfs_showattr_LINE(u32 value, char *buf)
 static ssize_t cxacru_sysfs_showattr_MODU(u32 value, char *buf)
 {
         static char *str[] = {
-                        NULL,
+                        "",
                         "ANSI T1.413",
                         "ITU-T G.992.1 (G.DMT)",
                         "ITU-T G.992.2 (G.LITE)"
         };
-        if (unlikely(value >= ARRAY_SIZE(str) || str[value] == NULL))
+        if (unlikely(value >= ARRAY_SIZE(str)))
                 return snprintf(buf, PAGE_SIZE, "%u\n", value);
         return snprintf(buf, PAGE_SIZE, "%s\n", str[value]);
 }
@@ -288,22 +319,28 @@ static ssize_t cxacru_sysfs_showattr_MODU(u32 value, char *buf)
 static ssize_t cxacru_sysfs_show_mac_address(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
-        struct usb_interface *intf = to_usb_interface(dev);
-        struct usbatm_data *usbatm_instance = usb_get_intfdata(intf);
-        struct atm_dev *atm_dev = usbatm_instance->atm_dev;
+        struct cxacru_data *instance = to_usbatm_driver_data(
+                        to_usb_interface(dev));
 
-        return snprintf(buf, PAGE_SIZE, "%pM\n", atm_dev->esi);
+        if (instance == NULL || instance->usbatm->atm_dev == NULL)
+                return -ENODEV;
+
+        return snprintf(buf, PAGE_SIZE, "%pM\n",
+                instance->usbatm->atm_dev->esi);
 }
 
 static ssize_t cxacru_sysfs_show_adsl_state(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
-        struct usb_interface *intf = to_usb_interface(dev);
-        struct usbatm_data *usbatm_instance = usb_get_intfdata(intf);
-        struct cxacru_data *instance = usbatm_instance->driver_data;
-        u32 value = instance->card_info[CXINF_LINE_STARTABLE];
-
         static char *str[] = { "running", "stopped" };
+        struct cxacru_data *instance = to_usbatm_driver_data(
+                        to_usb_interface(dev));
+        u32 value;
+
+        if (instance == NULL)
+                return -ENODEV;
+
+        value = instance->card_info[CXINF_LINE_STARTABLE];
         if (unlikely(value >= ARRAY_SIZE(str)))
                 return snprintf(buf, PAGE_SIZE, "%u\n", value);
         return snprintf(buf, PAGE_SIZE, "%s\n", str[value]);
@@ -312,9 +349,8 @@ static ssize_t cxacru_sysfs_show_adsl_state(struct device *dev,
 static ssize_t cxacru_sysfs_store_adsl_state(struct device *dev,
         struct device_attribute *attr, const char *buf, size_t count)
 {
-        struct usb_interface *intf = to_usb_interface(dev);
-        struct usbatm_data *usbatm_instance = usb_get_intfdata(intf);
-        struct cxacru_data *instance = usbatm_instance->driver_data;
+        struct cxacru_data *instance = to_usbatm_driver_data(
+                        to_usb_interface(dev));
         int ret;
         int poll = -1;
         char str_cmd[8];
@@ -328,13 +364,16 @@ static ssize_t cxacru_sysfs_store_adsl_state(struct device *dev,
                 return -EINVAL;
         ret = 0;
 
+        if (instance == NULL)
+                return -ENODEV;
+
         if (mutex_lock_interruptible(&instance->adsl_state_serialize))
                 return -ERESTARTSYS;
 
         if (!strcmp(str_cmd, "stop") || !strcmp(str_cmd, "restart")) {
                 ret = cxacru_cm(instance, CM_REQUEST_CHIP_ADSL_LINE_STOP, NULL, 0, NULL, 0);
                 if (ret < 0) {
-                        atm_err(usbatm_instance, "change adsl state:"
+                        atm_err(instance->usbatm, "change adsl state:"
                                 " CHIP_ADSL_LINE_STOP returned %d\n", ret);
 
                         ret = -EIO;
@@ -354,7 +393,7 @@ static ssize_t cxacru_sysfs_store_adsl_state(struct device *dev,
         if (!strcmp(str_cmd, "start") || !strcmp(str_cmd, "restart")) {
                 ret = cxacru_cm(instance, CM_REQUEST_CHIP_ADSL_LINE_START, NULL, 0, NULL, 0);
                 if (ret < 0) {
-                        atm_err(usbatm_instance, "change adsl state:"
+                        atm_err(instance->usbatm, "change adsl state:"
                                 " CHIP_ADSL_LINE_START returned %d\n", ret);
 
                         ret = -EIO;
@@ -407,6 +446,72 @@ static ssize_t cxacru_sysfs_store_adsl_state(struct device *dev,
         return ret;
 }
 
+/* CM_REQUEST_CARD_DATA_GET times out, so no show attribute */
+
+static ssize_t cxacru_sysfs_store_adsl_config(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct cxacru_data *instance = to_usbatm_driver_data(
+                        to_usb_interface(dev));
+        int len = strlen(buf);
+        int ret, pos, num;
+        __le32 data[CMD_PACKET_SIZE / 4];
+
+        if (!capable(CAP_NET_ADMIN))
+                return -EACCES;
+
+        if (instance == NULL)
+                return -ENODEV;
+
+        pos = 0;
+        num = 0;
+        while (pos < len) {
+                int tmp;
+                u32 index;
+                u32 value;
+
+                ret = sscanf(buf + pos, "%x=%x%n", &index, &value, &tmp);
+                if (ret < 2)
+                        return -EINVAL;
+                if (index < 0 || index > 0x7f)
+                        return -EINVAL;
+                pos += tmp;
+
+                /* skip trailing newline */
+                if (buf[pos] == '\n' && pos == len-1)
+                        pos++;
+
+                data[num * 2 + 1] = cpu_to_le32(index);
+                data[num * 2 + 2] = cpu_to_le32(value);
+                num++;
+
+                /* send config values when data buffer is full
+                 * or no more data
+                 */
+                if (pos >= len || num >= CMD_MAX_CONFIG) {
+                        char log[CMD_MAX_CONFIG * 12 + 1]; /* %02x=%08x */
+
+                        data[0] = cpu_to_le32(num);
+                        ret = cxacru_cm(instance, CM_REQUEST_CARD_DATA_SET,
+                                (u8 *) data, 4 + num * 8, NULL, 0);
+                        if (ret < 0) {
+                                atm_err(instance->usbatm,
+                                        "set card data returned %d\n", ret);
+                                return -EIO;
+                        }
+
+                        for (tmp = 0; tmp < num; tmp++)
+                                snprintf(log + tmp*12, 13, " %02x=%08x",
+                                        le32_to_cpu(data[tmp * 2 + 1]),
+                                        le32_to_cpu(data[tmp * 2 + 2]));
+                        atm_info(instance->usbatm, "config%s\n", log);
+                        num = 0;
+                }
+        }
+
+        return len;
+}
+
 /*
  * All device attributes are included in CXACRU_ALL_FILES
  * so that the same list can be used multiple times:
@@ -442,7 +547,8 @@ CXACRU_ATTR_##_action(CXINF_MODULATION,                MODU, modulation); \
 CXACRU_ATTR_##_action(CXINF_ADSL_HEADEND,              u32,  adsl_headend); \
 CXACRU_ATTR_##_action(CXINF_ADSL_HEADEND_ENVIRONMENT,  u32,  adsl_headend_environment); \
 CXACRU_ATTR_##_action(CXINF_CONTROLLER_VERSION,        u32,  adsl_controller_version); \
-CXACRU_CMD_##_action(                                        adsl_state);
+CXACRU_CMD_##_action(                                        adsl_state); \
+CXACRU_SET_##_action(                                        adsl_config);
 
 CXACRU_ALL_FILES(INIT);
 
@@ -596,7 +702,7 @@ static int cxacru_cm_get_array(struct cxacru_data *instance, enum cxacru_cm_requ
         len = ret / 4;
         for (offb = 0; offb < len; ) {
                 int l = le32_to_cpu(buf[offb++]);
-                if (l > stride || l > (len - offb) / 2) {
+                if (l < 0 || l > stride || l > (len - offb) / 2) {
                         if (printk_ratelimit())
                                 usb_err(instance->usbatm, "invalid data length from cm %#x: %d\n",
                                         cm, l);
@@ -649,9 +755,6 @@ static int cxacru_atm_start(struct usbatm_data *usbatm_instance,
 {
         struct cxacru_data *instance = usbatm_instance->driver_data;
         struct usb_interface *intf = usbatm_instance->usb_intf;
-        /*
-        struct atm_dev *atm_dev = usbatm_instance->atm_dev;
-        */
         int ret;
         int start_polling = 1;
 
@@ -697,6 +800,9 @@ static int cxacru_atm_start(struct usbatm_data *usbatm_instance,
         mutex_unlock(&instance->poll_state_serialize);
         mutex_unlock(&instance->adsl_state_serialize);
 
+        printk(KERN_INFO "%s%d: %s %pM\n", atm_dev->type, atm_dev->number,
+                        usbatm_instance->description, atm_dev->esi);
+
         if (start_polling)
                 cxacru_poll_status(&instance->poll_work.work);
         return 0;
@@ -873,11 +979,9 @@ cleanup:
 
 static void cxacru_upload_firmware(struct cxacru_data *instance,
                                    const struct firmware *fw,
-                                   const struct firmware *bp,
-                                   const struct firmware *cf)
+                                   const struct firmware *bp)
 {
         int ret;
-        int off;
         struct usbatm_data *usbatm = instance->usbatm;
         struct usb_device *usb_dev = usbatm->usb_dev;
         __le16 signature[] = { usb_dev->descriptor.idVendor,
@@ -911,6 +1015,7 @@ static void cxacru_upload_firmware(struct cxacru_data *instance,
         }
 
         /* Firmware */
+        usb_info(usbatm, "loading firmware\n");
         ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, FW_ADDR, fw->data, fw->size);
         if (ret) {
                 usb_err(usbatm, "Firmware upload failed: %d\n", ret);
@@ -919,6 +1024,7 @@ static void cxacru_upload_firmware(struct cxacru_data *instance,
 
         /* Boot ROM patch */
         if (instance->modem_type->boot_rom_patch) {
+                usb_info(usbatm, "loading boot ROM patch\n");
                 ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, BR_ADDR, bp->data, bp->size);
                 if (ret) {
                         usb_err(usbatm, "Boot ROM patching failed: %d\n", ret);
@@ -933,6 +1039,7 @@ static void cxacru_upload_firmware(struct cxacru_data *instance,
                 return;
         }
 
+        usb_info(usbatm, "starting device\n");
         if (instance->modem_type->boot_rom_patch) {
                 val = cpu_to_le32(BR_ADDR);
                 ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, BR_STACK_ADDR, (u8 *) &val, 4);
@@ -958,26 +1065,6 @@ static void cxacru_upload_firmware(struct cxacru_data *instance,
                 usb_err(usbatm, "modem failed to initialize: %d\n", ret);
                 return;
         }
-
-        /* Load config data (le32), doing one packet at a time */
-        if (cf)
-                for (off = 0; off < cf->size / 4; ) {
-                        __le32 buf[CMD_PACKET_SIZE / 4 - 1];
-                        int i, len = min_t(int, cf->size / 4 - off, CMD_PACKET_SIZE / 4 / 2 - 1);
-                        buf[0] = cpu_to_le32(len);
-                        for (i = 0; i < len; i++, off++) {
-                                buf[i * 2 + 1] = cpu_to_le32(off);
-                                memcpy(buf + i * 2 + 2, cf->data + off * 4, 4);
-                        }
-                        ret = cxacru_cm(instance, CM_REQUEST_CARD_DATA_SET,
-                                        (u8 *) buf, len, NULL, 0);
-                        if (ret < 0) {
-                                usb_err(usbatm, "load config data failed: %d\n", ret);
-                                return;
-                        }
-                }
-
-        msleep_interruptible(4000);
 }
 
 static int cxacru_find_firmware(struct cxacru_data *instance,
@@ -1003,7 +1090,7 @@ static int cxacru_find_firmware(struct cxacru_data *instance,
 static int cxacru_heavy_init(struct usbatm_data *usbatm_instance,
                              struct usb_interface *usb_intf)
 {
-        const struct firmware *fw, *bp, *cf;
+        const struct firmware *fw, *bp;
         struct cxacru_data *instance = usbatm_instance->driver_data;
 
         int ret = cxacru_find_firmware(instance, "fw", &fw);
@@ -1021,13 +1108,8 @@ static int cxacru_heavy_init(struct usbatm_data *usbatm_instance,
                 }
         }
 
-        if (cxacru_find_firmware(instance, "cf", &cf))          /* optional */
-                cf = NULL;
-
-        cxacru_upload_firmware(instance, fw, bp, cf);
+        cxacru_upload_firmware(instance, fw, bp);
 
-        if (cf)
-                release_firmware(cf);
         if (instance->modem_type->boot_rom_patch)
                 release_firmware(bp);
         release_firmware(fw);
diff --git a/drivers/usb/atm/speedtch.c b/drivers/usb/atm/speedtch.c
index 3e862401a638..1e9ba4bdffef 100644
--- a/drivers/usb/atm/speedtch.c
+++ b/drivers/usb/atm/speedtch.c
@@ -27,7 +27,6 @@
 #include <linux/device.h>
 #include <linux/errno.h>
 #include <linux/firmware.h>
-#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index d171b563e94c..25f01b536f67 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -66,6 +66,7 @@
 #include <linux/kthread.h>
 #include <linux/mutex.h>
 #include <linux/freezer.h>
+#include <linux/slab.h>
 
 #include <asm/unaligned.h>
 
@@ -667,12 +668,12 @@ static void uea_upload_pre_firmware(const struct firmware *fw_entry, void *conte
         else
                 uea_info(usb, "firmware uploaded\n");
 
-        uea_leaves(usb);
-        return;
+        goto err;
 
 err_fw_corrupted:
         uea_err(usb, "firmware is corrupted\n");
 err:
+        release_firmware(fw_entry);
         uea_leaves(usb);
 }
 
@@ -705,7 +706,8 @@ static int uea_load_firmware(struct usb_device *usb, unsigned int ver)
                 break;
         }
 
-        ret = request_firmware_nowait(THIS_MODULE, 1, fw_name, &usb->dev, usb, uea_upload_pre_firmware);
+        ret = request_firmware_nowait(THIS_MODULE, 1, fw_name, &usb->dev,
+                                      GFP_KERNEL, usb, uea_upload_pre_firmware);
         if (ret)
                 uea_err(usb, "firmware %s is not available\n", fw_name);
         else
@@ -1958,7 +1960,7 @@ static void uea_dispatch_cmv_e1(struct uea_softc *sc, struct intr_pkt *intr)
                 goto bad1;
 
         /* FIXME : ADI930 reply wrong preambule (func = 2, sub = 2) to
-         * the first MEMACESS cmv. Ignore it...
+         * the first MEMACCESS cmv. Ignore it...
          */
         if (cmv->bFunction != dsc->function) {
                 if (UEA_CHIP_VERSION(sc) == ADI930
diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index fbea8563df1e..9b53e8df4648 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -1333,6 +1333,7 @@ void usbatm_usb_disconnect(struct usb_interface *intf)
         if (instance->atm_dev) {
                 sysfs_remove_link(&instance->atm_dev->class_dev.kobj, "device");
                 atm_dev_deregister(instance->atm_dev);
+                instance->atm_dev = NULL;
         }
 
         usbatm_put_instance(instance);  /* taken in usbatm_usb_probe */
@@ -1348,7 +1349,7 @@ static int __init usbatm_usb_init(void)
 {
         dbg("%s: driver version %s", __func__, DRIVER_VERSION);
 
-        if (sizeof(struct usbatm_control) > sizeof(((struct sk_buff *) 0)->cb)) {
+        if (sizeof(struct usbatm_control) > FIELD_SIZEOF(struct sk_buff, cb)) {
                 printk(KERN_ERR "%s unusable with this kernel!\n", usbatm_driver_name);
                 return -EIO;
         }
diff --git a/drivers/usb/atm/usbatm.h b/drivers/usb/atm/usbatm.h
index f6f4508a9d42..0863f85fcc26 100644
--- a/drivers/usb/atm/usbatm.h
+++ b/drivers/usb/atm/usbatm.h
@@ -204,4 +204,19 @@ struct usbatm_data {
         struct urb *urbs[0];
 };
 
+static inline void *to_usbatm_driver_data(struct usb_interface *intf)
+{
+        struct usbatm_data *usbatm_instance;
+
+        if (intf == NULL)
+                return NULL;
+
+        usbatm_instance = usb_get_intfdata(intf);
+
+        if (usbatm_instance == NULL) /* set NULL before unbind() */
+                return NULL;
+
+        return usbatm_instance->driver_data; /* set NULL after unbind() */
+}
+
 #endif  /* _USBATM_H_ */
diff --git a/drivers/usb/c67x00/c67x00-drv.c b/drivers/usb/c67x00/c67x00-drv.c
index 5633bc5c8bf2..b6d49234e521 100644
--- a/drivers/usb/c67x00/c67x00-drv.c
+++ b/drivers/usb/c67x00/c67x00-drv.c
@@ -37,6 +37,7 @@
 #include <linux/device.h>
 #include <linux/io.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/usb/c67x00.h>
 
@@ -137,13 +138,13 @@ static int __devinit c67x00_drv_probe(struct platform_device *pdev)
         if (!c67x00)
                 return -ENOMEM;
 
-        if (!request_mem_region(res->start, res->end - res->start + 1,
+        if (!request_mem_region(res->start, resource_size(res),
                                 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);
+        c67x00->hpi.base = ioremap(res->start, resource_size(res));
         if (!c67x00->hpi.base) {
                 dev_err(&pdev->dev, "Unable to map HPI registers\n");
                 ret = -EIO;
@@ -182,7 +183,7 @@ static int __devinit c67x00_drv_probe(struct platform_device *pdev)
  request_irq_failed:
         iounmap(c67x00->hpi.base);
  map_failed:
-        release_mem_region(res->start, res->end - res->start + 1);
+        release_mem_region(res->start, resource_size(res));
  request_mem_failed:
         kfree(c67x00);
 
@@ -208,7 +209,7 @@ static int __devexit c67x00_drv_remove(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (res)
-                release_mem_region(res->start, res->end - res->start + 1);
+                release_mem_region(res->start, resource_size(res));
 
         kfree(c67x00);
 
diff --git a/drivers/usb/c67x00/c67x00-sched.c b/drivers/usb/c67x00/c67x00-sched.c
index 85dfe2965661..f6b3c253f3fa 100644
--- a/drivers/usb/c67x00/c67x00-sched.c
+++ b/drivers/usb/c67x00/c67x00-sched.c
@@ -22,6 +22,7 @@
  */
 
 #include <linux/kthread.h>
+#include <linux/slab.h>
 
 #include "c67x00.h"
 #include "c67x00-hcd.h"
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index e4eca7810bcf..5e1a253b08a0 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -170,6 +170,7 @@ static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 {
         wb->use = 0;
         acm->transmitting--;
+        usb_autopm_put_interface_async(acm->control);
 }
 
 /*
@@ -211,9 +212,12 @@ static int acm_write_start(struct acm *acm, int wbn)
         }
 
         dbg("%s susp_count: %d", __func__, acm->susp_count);
+        usb_autopm_get_interface_async(acm->control);
         if (acm->susp_count) {
-                acm->delayed_wb = wb;
-                schedule_work(&acm->waker);
+                if (!acm->delayed_wb)
+                        acm->delayed_wb = wb;
+                else
+                        usb_autopm_put_interface_async(acm->control);
                 spin_unlock_irqrestore(&acm->write_lock, flags);
                 return 0;       /* A white lie */
         }
@@ -424,7 +428,6 @@ next_buffer:
                 throttled = acm->throttle;
                 spin_unlock_irqrestore(&acm->throttle_lock, flags);
                 if (!throttled) {
-                        tty_buffer_request_room(tty, buf->size);
                         tty_insert_flip_string(tty, buf->base, buf->size);
                         tty_flip_buffer_push(tty);
                 } else {
@@ -534,23 +537,6 @@ static void acm_softint(struct work_struct *work)
         tty_kref_put(tty);
 }
 
-static void acm_waker(struct work_struct *waker)
-{
-        struct acm *acm = container_of(waker, struct acm, waker);
-        int rv;
-
-        rv = usb_autopm_get_interface(acm->control);
-        if (rv < 0) {
-                dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__);
-                return;
-        }
-        if (acm->delayed_wb) {
-                acm_start_wb(acm, acm->delayed_wb);
-                acm->delayed_wb = NULL;
-        }
-        usb_autopm_put_interface(acm->control);
-}
-
 /*
  * TTY handlers
  */
@@ -566,7 +552,7 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 
         acm = acm_table[tty->index];
         if (!acm || !acm->dev)
-                goto err_out;
+                goto out;
         else
                 rv = 0;
 
@@ -582,8 +568,9 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 
         mutex_lock(&acm->mutex);
         if (acm->port.count++) {
+                mutex_unlock(&acm->mutex);
                 usb_autopm_put_interface(acm->control);
-                goto done;
+                goto out;
         }
 
         acm->ctrlurb->dev = acm->dev;
@@ -612,18 +599,18 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
         rv = tty_port_block_til_ready(&acm->port, tty, filp);
         tasklet_schedule(&acm->urb_task);
-done:
+
         mutex_unlock(&acm->mutex);
-err_out:
+out:
         mutex_unlock(&open_mutex);
         return rv;
 
 full_bailout:
         usb_kill_urb(acm->ctrlurb);
 bail_out:
-        usb_autopm_put_interface(acm->control);
         acm->port.count--;
         mutex_unlock(&acm->mutex);
+        usb_autopm_put_interface(acm->control);
 early_bail:
         mutex_unlock(&open_mutex);
         tty_port_tty_set(&acm->port, NULL);
@@ -1023,7 +1010,7 @@ static int acm_probe(struct usb_interface *intf,
                 case USB_CDC_CALL_MANAGEMENT_TYPE:
                         call_management_function = buffer[3];
                         call_interface_num = buffer[4];
-                        if ((call_management_function & 3) != 3)
+                        if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
                         break;
                 default:
@@ -1178,7 +1165,6 @@ made_compressed_probe:
         acm->urb_task.func = acm_rx_tasklet;
         acm->urb_task.data = (unsigned long) acm;
         INIT_WORK(&acm->work, acm_softint);
-        INIT_WORK(&acm->waker, acm_waker);
         init_waitqueue_head(&acm->drain_wait);
         spin_lock_init(&acm->throttle_lock);
         spin_lock_init(&acm->write_lock);
@@ -1343,7 +1329,6 @@ static void stop_data_traffic(struct acm *acm)
         tasklet_enable(&acm->urb_task);
 
         cancel_work_sync(&acm->work);
-        cancel_work_sync(&acm->waker);
 }
 
 static void acm_disconnect(struct usb_interface *intf)
@@ -1435,6 +1420,7 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
 static int acm_resume(struct usb_interface *intf)
 {
         struct acm *acm = usb_get_intfdata(intf);
+        struct acm_wb *wb;
         int rv = 0;
         int cnt;
 
@@ -1449,6 +1435,21 @@ static int acm_resume(struct usb_interface *intf)
         mutex_lock(&acm->mutex);
         if (acm->port.count) {
                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
+
+                spin_lock_irq(&acm->write_lock);
+                if (acm->delayed_wb) {
+                        wb = acm->delayed_wb;
+                        acm->delayed_wb = NULL;
+                        spin_unlock_irq(&acm->write_lock);
+                        acm_start_wb(acm, wb);
+                } else {
+                        spin_unlock_irq(&acm->write_lock);
+                }
+
+                /*
+                 * delayed error checking because we must
+                 * do the write path at all cost
+                 */
                 if (rv < 0)
                         goto err_out;
 
@@ -1460,12 +1461,35 @@ err_out:
         return rv;
 }
 
+static int acm_reset_resume(struct usb_interface *intf)
+{
+        struct acm *acm = usb_get_intfdata(intf);
+        struct tty_struct *tty;
+
+        mutex_lock(&acm->mutex);
+        if (acm->port.count) {
+                tty = tty_port_tty_get(&acm->port);
+                if (tty) {
+                        tty_hangup(tty);
+                        tty_kref_put(tty);
+                }
+        }
+        mutex_unlock(&acm->mutex);
+        return acm_resume(intf);
+}
+
 #endif /* CONFIG_PM */
+
+#define NOKIA_PCSUITE_ACM_INFO(x) \
+                USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
+                USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
+                USB_CDC_ACM_PROTO_VENDOR)
+
 /*
  * USB driver structure.
  */
 
-static struct usb_device_id acm_ids[] = {
+static const struct usb_device_id acm_ids[] = {
         /* quirky and broken devices */
         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
@@ -1518,6 +1542,65 @@ static struct usb_device_id acm_ids[] = {
         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
         },
+        { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
+        .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
+        },
+
+        /* Nokia S60 phones expose two ACM channels. The first is
+         * a modem and is picked up by the standard AT-command
+         * information below. The second is 'vendor-specific' but
+         * is treated as a serial device at the S60 end, so we want
+         * to expose it on Linux too. */
+        { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
+        { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
+        { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
+        { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
+        { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
+        { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
+        { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
+        { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
+        { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
+        { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
+        { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
+        { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
+        { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
+        { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
+        { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
+        { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
+        { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
+        { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
+        { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
+        { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
+        { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
+        { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
+        { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
+        { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
+        { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
+        { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
+        { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
+        { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
+        { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
+        { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
+        { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
+
+        /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
+
+        /* Support Lego NXT using pbLua firmware */
+        { USB_DEVICE(0x0694, 0xff00),
+        .driver_info = NOT_A_MODEM,
+        },
 
         /* control interfaces with various AT-command sets */
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
@@ -1533,7 +1616,6 @@ static struct usb_device_id acm_ids[] = {
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
                 USB_CDC_ACM_PROTO_AT_CDMA) },
 
-        /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
         { }
 };
 
@@ -1546,6 +1628,7 @@ static struct usb_driver acm_driver = {
 #ifdef CONFIG_PM
         .suspend =      acm_suspend,
         .resume =       acm_resume,
+        .reset_resume = acm_reset_resume,
 #endif
         .id_table =     acm_ids,
 #ifdef CONFIG_PM
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h
index c4a0ee8ffccf..4a8e87ec6ce9 100644
--- a/drivers/usb/class/cdc-acm.h
+++ b/drivers/usb/class/cdc-acm.h
@@ -112,7 +112,6 @@ struct acm {
         struct mutex mutex;
         struct usb_cdc_line_coding line;                /* bits, stop, parity */
         struct work_struct work;                        /* work queue entry for line discipline waking up */
-        struct work_struct waker;
         wait_queue_head_t drain_wait;                   /* close processing */
         struct tasklet_struct urb_task;                 /* rx processing */
         spinlock_t throttle_lock;                       /* synchronize throtteling and read callback */
@@ -137,3 +136,4 @@ struct acm {
 #define NO_UNION_NORMAL                 1
 #define SINGLE_RX_URB                   2
 #define NO_CAP_LINE                     4
+#define NOT_A_MODEM                     8
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index 3e564bfe17d1..189141ca4e05 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -31,7 +31,7 @@
 #define DRIVER_AUTHOR "Oliver Neukum"
 #define DRIVER_DESC "USB Abstract Control Model driver for USB WCM Device Management"
 
-static struct usb_device_id wdm_ids[] = {
+static const struct usb_device_id wdm_ids[] = {
         {
                 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
                                  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -52,7 +52,8 @@ MODULE_DEVICE_TABLE (usb, wdm_ids);
 #define WDM_READ                4
 #define WDM_INT_STALL           5
 #define WDM_POLL_RUNNING        6
-
+#define WDM_RESPONDING          7
+#define WDM_SUSPENDING          8
 
 #define WDM_MAX                 16
 
@@ -87,9 +88,7 @@ struct wdm_device {
         int                     count;
         dma_addr_t              shandle;
         dma_addr_t              ihandle;
-        struct mutex            wlock;
-        struct mutex            rlock;
-        struct mutex            plock;
+        struct mutex            lock;
         wait_queue_head_t       wait;
         struct work_struct      rxwork;
         int                     werr;
@@ -117,21 +116,22 @@ static void wdm_in_callback(struct urb *urb)
         int status = urb->status;
 
         spin_lock(&desc->iuspin);
+        clear_bit(WDM_RESPONDING, &desc->flags);
 
         if (status) {
                 switch (status) {
                 case -ENOENT:
                         dev_dbg(&desc->intf->dev,
                                 "nonzero urb status received: -ENOENT");
-                        break;
+                        goto skip_error;
                 case -ECONNRESET:
                         dev_dbg(&desc->intf->dev,
                                 "nonzero urb status received: -ECONNRESET");
-                        break;
+                        goto skip_error;
                 case -ESHUTDOWN:
                         dev_dbg(&desc->intf->dev,
                                 "nonzero urb status received: -ESHUTDOWN");
-                        break;
+                        goto skip_error;
                 case -EPIPE:
                         dev_err(&desc->intf->dev,
                                 "nonzero urb status received: -EPIPE\n");
@@ -147,6 +147,7 @@ static void wdm_in_callback(struct urb *urb)
         desc->reslength = urb->actual_length;
         memmove(desc->ubuf + desc->length, desc->inbuf, desc->reslength);
         desc->length += desc->reslength;
+skip_error:
         wake_up(&desc->wait);
 
         set_bit(WDM_READ, &desc->flags);
@@ -229,13 +230,16 @@ static void wdm_int_callback(struct urb *urb)
         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)) {
+        set_bit(WDM_RESPONDING, &desc->flags);
+        if (!test_bit(WDM_DISCONNECTING, &desc->flags)
+                && !test_bit(WDM_SUSPENDING, &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) {
+                clear_bit(WDM_RESPONDING, &desc->flags);
                 if (rv == -EPERM)
                         return;
                 if (rv == -ENOMEM) {
@@ -305,14 +309,38 @@ static ssize_t wdm_write
         if (we < 0)
                 return -EIO;
 
-        r = mutex_lock_interruptible(&desc->wlock); /* concurrent writes */
+        desc->outbuf = buf = kmalloc(count, GFP_KERNEL);
+        if (!buf) {
+                rv = -ENOMEM;
+                goto outnl;
+        }
+
+        r = copy_from_user(buf, buffer, count);
+        if (r > 0) {
+                kfree(buf);
+                rv = -EFAULT;
+                goto outnl;
+        }
+
+        /* concurrent writes and disconnect */
+        r = mutex_lock_interruptible(&desc->lock);
         rv = -ERESTARTSYS;
-        if (r)
+        if (r) {
+                kfree(buf);
                 goto outnl;
+        }
+
+        if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
+                kfree(buf);
+                rv = -ENODEV;
+                goto outnp;
+        }
 
         r = usb_autopm_get_interface(desc->intf);
-        if (r < 0)
+        if (r < 0) {
+                kfree(buf);
                 goto outnp;
+        }
 
         if (!file->f_flags && O_NONBLOCK)
                 r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
@@ -320,24 +348,8 @@ static ssize_t wdm_write
         else
                 if (test_bit(WDM_IN_USE, &desc->flags))
                         r = -EAGAIN;
-        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) {
+        if (r < 0) {
                 kfree(buf);
-                rv = -EFAULT;
                 goto out;
         }
 
@@ -374,7 +386,7 @@ static ssize_t wdm_write
 out:
         usb_autopm_put_interface(desc->intf);
 outnp:
-        mutex_unlock(&desc->wlock);
+        mutex_unlock(&desc->lock);
 outnl:
         return rv < 0 ? rv : count;
 }
@@ -387,7 +399,7 @@ static ssize_t wdm_read
         struct wdm_device *desc = file->private_data;
 
 
-        rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
+        rv = mutex_lock_interruptible(&desc->lock); /*concurrent reads */
         if (rv < 0)
                 return -ERESTARTSYS;
 
@@ -424,11 +436,8 @@ retry:
                 spin_lock_irq(&desc->iuspin);
 
                 if (desc->rerr) { /* read completed, error happened */
-                        int t = desc->rerr;
                         desc->rerr = 0;
                         spin_unlock_irq(&desc->iuspin);
-                        dev_err(&desc->intf->dev,
-                                "reading had resulted in %d\n", t);
                         rv = -EIO;
                         goto err;
                 }
@@ -465,9 +474,7 @@ retry:
         rv = cntr;
 
 err:
-        mutex_unlock(&desc->rlock);
-        if (rv < 0 && rv != -EAGAIN)
-                dev_err(&desc->intf->dev, "wdm_read: exit error\n");
+        mutex_unlock(&desc->lock);
         return rv;
 }
 
@@ -533,7 +540,7 @@ static int wdm_open(struct inode *inode, struct file *file)
         }
         intf->needs_remote_wakeup = 1;
 
-        mutex_lock(&desc->plock);
+        mutex_lock(&desc->lock);
         if (!desc->count++) {
                 rv = usb_submit_urb(desc->validity, GFP_KERNEL);
                 if (rv < 0) {
@@ -544,7 +551,7 @@ static int wdm_open(struct inode *inode, struct file *file)
         } else {
                 rv = 0;
         }
-        mutex_unlock(&desc->plock);
+        mutex_unlock(&desc->lock);
         usb_autopm_put_interface(desc->intf);
 out:
         mutex_unlock(&wdm_mutex);
@@ -556,9 +563,9 @@ static int wdm_release(struct inode *inode, struct file *file)
         struct wdm_device *desc = file->private_data;
 
         mutex_lock(&wdm_mutex);
-        mutex_lock(&desc->plock);
+        mutex_lock(&desc->lock);
         desc->count--;
-        mutex_unlock(&desc->plock);
+        mutex_unlock(&desc->lock);
 
         if (!desc->count) {
                 dev_dbg(&desc->intf->dev, "wdm_release: cleanup");
@@ -655,9 +662,7 @@ next_desc:
         desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);
         if (!desc)
                 goto out;
-        mutex_init(&desc->wlock);
-        mutex_init(&desc->rlock);
-        mutex_init(&desc->plock);
+        mutex_init(&desc->lock);
         spin_lock_init(&desc->iuspin);
         init_waitqueue_head(&desc->wait);
         desc->wMaxCommand = maxcom;
@@ -771,14 +776,17 @@ static void wdm_disconnect(struct usb_interface *intf)
         /* to terminate pending flushes */
         clear_bit(WDM_IN_USE, &desc->flags);
         spin_unlock_irqrestore(&desc->iuspin, flags);
-        cancel_work_sync(&desc->rxwork);
+        mutex_lock(&desc->lock);
         kill_urbs(desc);
+        cancel_work_sync(&desc->rxwork);
+        mutex_unlock(&desc->lock);
         wake_up_all(&desc->wait);
         if (!desc->count)
                 cleanup(desc);
         mutex_unlock(&wdm_mutex);
 }
 
+#ifdef CONFIG_PM
 static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct wdm_device *desc = usb_get_intfdata(intf);
@@ -786,22 +794,30 @@ static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
 
         dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor);
 
-        mutex_lock(&desc->plock);
-#ifdef CONFIG_PM
+        /* if this is an autosuspend the caller does the locking */
+        if (!(message.event & PM_EVENT_AUTO))
+                mutex_lock(&desc->lock);
+        spin_lock_irq(&desc->iuspin);
+
         if ((message.event & PM_EVENT_AUTO) &&
-                        test_bit(WDM_IN_USE, &desc->flags)) {
+                        (test_bit(WDM_IN_USE, &desc->flags)
+                        || test_bit(WDM_RESPONDING, &desc->flags))) {
+                spin_unlock_irq(&desc->iuspin);
                 rv = -EBUSY;
         } else {
-#endif
-                cancel_work_sync(&desc->rxwork);
+
+                set_bit(WDM_SUSPENDING, &desc->flags);
+                spin_unlock_irq(&desc->iuspin);
+                /* callback submits work - order is essential */
                 kill_urbs(desc);
-#ifdef CONFIG_PM
+                cancel_work_sync(&desc->rxwork);
         }
-#endif
-        mutex_unlock(&desc->plock);
+        if (!(message.event & PM_EVENT_AUTO))
+                mutex_unlock(&desc->lock);
 
         return rv;
 }
+#endif
 
 static int recover_from_urb_loss(struct wdm_device *desc)
 {
@@ -815,23 +831,27 @@ static int recover_from_urb_loss(struct wdm_device *desc)
         }
         return rv;
 }
+
+#ifdef CONFIG_PM
 static int wdm_resume(struct usb_interface *intf)
 {
         struct wdm_device *desc = usb_get_intfdata(intf);
         int rv;
 
         dev_dbg(&desc->intf->dev, "wdm%d_resume\n", intf->minor);
-        mutex_lock(&desc->plock);
+
+        clear_bit(WDM_SUSPENDING, &desc->flags);
         rv = recover_from_urb_loss(desc);
-        mutex_unlock(&desc->plock);
+
         return rv;
 }
+#endif
 
 static int wdm_pre_reset(struct usb_interface *intf)
 {
         struct wdm_device *desc = usb_get_intfdata(intf);
 
-        mutex_lock(&desc->plock);
+        mutex_lock(&desc->lock);
         return 0;
 }
 
@@ -841,7 +861,7 @@ static int wdm_post_reset(struct usb_interface *intf)
         int rv;
 
         rv = recover_from_urb_loss(desc);
-        mutex_unlock(&desc->plock);
+        mutex_unlock(&desc->lock);
         return 0;
 }
 
@@ -849,9 +869,11 @@ static struct usb_driver wdm_driver = {
         .name =         "cdc_wdm",
         .probe =        wdm_probe,
         .disconnect =   wdm_disconnect,
+#ifdef CONFIG_PM
         .suspend =      wdm_suspend,
         .resume =       wdm_resume,
         .reset_resume = wdm_resume,
+#endif
         .pre_reset =    wdm_pre_reset,
         .post_reset =   wdm_post_reset,
         .id_table =     wdm_ids,
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 9bc112ee7803..93b5f85d7ceb 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -163,7 +163,6 @@ struct usblp {
         unsigned char           used;                   /* True if open */
         unsigned char           present;                /* True if not disconnected */
         unsigned char           bidir;                  /* interface is bidirectional */
-        unsigned char           sleeping;               /* interface is suspended */
         unsigned char           no_paper;               /* Paper Out happened */
         unsigned char           *device_id_string;      /* IEEE 1284 DEVICE ID string (ptr) */
                                                         /* first 2 bytes are (big-endian) length */
@@ -191,7 +190,6 @@ static void usblp_dump(struct usblp *usblp) {
         dbg("quirks=%d", usblp->quirks);
         dbg("used=%d", usblp->used);
         dbg("bidir=%d", usblp->bidir);
-        dbg("sleeping=%d", usblp->sleeping);
         dbg("device_id_string=\"%s\"",
                 usblp->device_id_string ?
                         usblp->device_id_string + 2 :
@@ -376,7 +374,7 @@ static int usblp_check_status(struct usblp *usblp, int err)
 
 static int handle_bidir (struct usblp *usblp)
 {
-        if (usblp->bidir && usblp->used && !usblp->sleeping) {
+        if (usblp->bidir && usblp->used) {
                 if (usblp_submit_read(usblp) < 0)
                         return -EIO;
         }
@@ -503,11 +501,6 @@ static long usblp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 goto done;
         }
 
-        if (usblp->sleeping) {
-                retval = -ENODEV;
-                goto done;
-        }
-
         dbg("usblp_ioctl: cmd=0x%x (%c nr=%d len=%d dir=%d)", cmd, _IOC_TYPE(cmd),
                 _IOC_NR(cmd), _IOC_SIZE(cmd), _IOC_DIR(cmd) );
 
@@ -914,8 +907,6 @@ static int usblp_wtest(struct usblp *usblp, int nonblock)
                 return 0;
         }
         spin_unlock_irqrestore(&usblp->lock, flags);
-        if (usblp->sleeping)
-                return -ENODEV;
         if (nonblock)
                 return -EAGAIN;
         return 1;
@@ -968,8 +959,6 @@ static int usblp_rtest(struct usblp *usblp, int nonblock)
                 return 0;
         }
         spin_unlock_irqrestore(&usblp->lock, flags);
-        if (usblp->sleeping)
-                return -ENODEV;
         if (nonblock)
                 return -EAGAIN;
         return 1;
@@ -1377,12 +1366,10 @@ static void usblp_disconnect(struct usb_interface *intf)
         mutex_unlock (&usblp_mutex);
 }
 
-static int usblp_suspend (struct usb_interface *intf, pm_message_t message)
+static int usblp_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct usblp *usblp = usb_get_intfdata (intf);
 
-        /* we take no more IO */
-        usblp->sleeping = 1;
         usblp_unlink_urbs(usblp);
 #if 0 /* XXX Do we want this? What if someone is reading, should we fail? */
         /* not strictly necessary, but just in case */
@@ -1393,18 +1380,17 @@ static int usblp_suspend (struct usb_interface *intf, pm_message_t message)
         return 0;
 }
 
-static int usblp_resume (struct usb_interface *intf)
+static int usblp_resume(struct usb_interface *intf)
 {
         struct usblp *usblp = usb_get_intfdata (intf);
         int r;
 
-        usblp->sleeping = 0;
         r = handle_bidir (usblp);
 
         return r;
 }
 
-static struct usb_device_id usblp_ids [] = {
+static const struct usb_device_id usblp_ids[] = {
         { USB_DEVICE_INFO(7, 1, 1) },
         { USB_DEVICE_INFO(7, 1, 2) },
         { USB_DEVICE_INFO(7, 1, 3) },
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c
index 2473cf0c6b1d..3e7c1b800ebb 100644
--- a/drivers/usb/class/usbtmc.c
+++ b/drivers/usb/class/usbtmc.c
@@ -1,5 +1,5 @@
 /**
- * drivers/usb/class/usbtmc.c - USB Test & Measurment class driver
+ * drivers/usb/class/usbtmc.c - USB Test & Measurement class driver
  *
  * Copyright (C) 2007 Stefan Kopp, Gechingen, Germany
  * Copyright (C) 2008 Novell, Inc.
@@ -25,6 +25,7 @@
 #include <linux/fs.h>
 #include <linux/uaccess.h>
 #include <linux/kref.h>
+#include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/usb.h>
 #include <linux/usb/tmc.h>
@@ -48,7 +49,7 @@
  */
 #define USBTMC_MAX_READS_TO_CLEAR_BULK_IN       100
 
-static struct usb_device_id usbtmc_devices[] = {
+static const struct usb_device_id usbtmc_devices[] = {
         { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 0), },
         { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 1), },
         { 0, } /* terminating entry */
@@ -347,13 +348,8 @@ usbtmc_abort_bulk_out_check_status:
         goto exit;
 
 usbtmc_abort_bulk_out_clear_halt:
-        rv = usb_control_msg(data->usb_dev,
-                             usb_sndctrlpipe(data->usb_dev, 0),
-                             USB_REQ_CLEAR_FEATURE,
-                             USB_DIR_OUT | USB_TYPE_STANDARD |
-                             USB_RECIP_ENDPOINT,
-                             USB_ENDPOINT_HALT, data->bulk_out, buffer,
-                             0, USBTMC_TIMEOUT);
+        rv = usb_clear_halt(data->usb_dev,
+                            usb_sndbulkpipe(data->usb_dev, data->bulk_out));
 
         if (rv < 0) {
                 dev_err(dev, "usb_control_msg returned %d\n", rv);
@@ -562,10 +558,16 @@ static ssize_t usbtmc_write(struct file *filp, const char __user *buf,
                 n_bytes = roundup(12 + this_part, 4);
                 memset(buffer + 12 + this_part, 0, n_bytes - (12 + this_part));
 
-                retval = usb_bulk_msg(data->usb_dev,
-                                      usb_sndbulkpipe(data->usb_dev,
-                                                      data->bulk_out),
-                                      buffer, n_bytes, &actual, USBTMC_TIMEOUT);
+                do {
+                        retval = usb_bulk_msg(data->usb_dev,
+                                              usb_sndbulkpipe(data->usb_dev,
+                                                              data->bulk_out),
+                                              buffer, n_bytes,
+                                              &actual, USBTMC_TIMEOUT);
+                        if (retval != 0)
+                                break;
+                        n_bytes -= actual;
+                } while (n_bytes);
 
                 data->bTag_last_write = data->bTag;
                 data->bTag++;
@@ -702,14 +704,8 @@ usbtmc_clear_check_status:
 
 usbtmc_clear_bulk_out_halt:
 
-        rv = usb_control_msg(data->usb_dev,
-                             usb_sndctrlpipe(data->usb_dev, 0),
-                             USB_REQ_CLEAR_FEATURE,
-                             USB_DIR_OUT | USB_TYPE_STANDARD |
-                             USB_RECIP_ENDPOINT,
-                             USB_ENDPOINT_HALT,
-                             data->bulk_out, buffer, 0,
-                             USBTMC_TIMEOUT);
+        rv = usb_clear_halt(data->usb_dev,
+                            usb_sndbulkpipe(data->usb_dev, data->bulk_out));
         if (rv < 0) {
                 dev_err(dev, "usb_control_msg returned %d\n", rv);
                 goto exit;
@@ -730,13 +726,8 @@ static int usbtmc_ioctl_clear_out_halt(struct usbtmc_device_data *data)
         if (!buffer)
                 return -ENOMEM;
 
-        rv = usb_control_msg(data->usb_dev,
-                             usb_sndctrlpipe(data->usb_dev, 0),
-                             USB_REQ_CLEAR_FEATURE,
-                             USB_DIR_OUT | USB_TYPE_STANDARD |
-                             USB_RECIP_ENDPOINT,
-                             USB_ENDPOINT_HALT, data->bulk_out,
-                             buffer, 0, USBTMC_TIMEOUT);
+        rv = usb_clear_halt(data->usb_dev,
+                            usb_sndbulkpipe(data->usb_dev, data->bulk_out));
 
         if (rv < 0) {
                 dev_err(&data->usb_dev->dev, "usb_control_msg returned %d\n",
@@ -759,12 +750,8 @@ static int usbtmc_ioctl_clear_in_halt(struct usbtmc_device_data *data)
         if (!buffer)
                 return -ENOMEM;
 
-        rv = usb_control_msg(data->usb_dev, usb_sndctrlpipe(data->usb_dev, 0),
-                             USB_REQ_CLEAR_FEATURE,
-                             USB_DIR_OUT | USB_TYPE_STANDARD |
-                             USB_RECIP_ENDPOINT,
-                             USB_ENDPOINT_HALT, data->bulk_in, buffer, 0,
-                             USBTMC_TIMEOUT);
+        rv = usb_clear_halt(data->usb_dev,
+                            usb_rcvbulkpipe(data->usb_dev, data->bulk_in));
 
         if (rv < 0) {
                 dev_err(&data->usb_dev->dev, "usb_control_msg returned %d\n",
@@ -1109,13 +1096,13 @@ static void usbtmc_disconnect(struct usb_interface *intf)
         kref_put(&data->kref, usbtmc_delete);
 }
 
-static int usbtmc_suspend (struct usb_interface *intf, pm_message_t message)
+static int usbtmc_suspend(struct usb_interface *intf, pm_message_t message)
 {
         /* this driver does not have pending URBs */
         return 0;
 }
 
-static int usbtmc_resume (struct usb_interface *intf)
+static int usbtmc_resume(struct usb_interface *intf)
 {
         return 0;
 }
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index ad925946f869..7e594449600e 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -91,8 +91,8 @@ config USB_DYNAMIC_MINORS
           If you are unsure about this, say N here.
 
 config USB_SUSPEND
-        bool "USB selective suspend/resume and wakeup"
-        depends on USB && PM
+        bool "USB runtime power management (suspend/resume and wakeup)"
+        depends on USB && PM_RUNTIME
         help
           If you say Y here, you can use driver calls or the sysfs
           "power/level" file to suspend or resume individual USB
@@ -109,7 +109,7 @@ config USB_SUSPEND
 config USB_OTG
         bool
         depends on USB && EXPERIMENTAL
-        select USB_SUSPEND
+        depends on USB_SUSPEND
         default n
 
 
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index 96f11715cd26..19bc03a9fecf 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -50,7 +50,7 @@
 
 #include <linux/fs.h>
 #include <linux/mm.h>
-#include <linux/slab.h>
+#include <linux/gfp.h>
 #include <linux/poll.h>
 #include <linux/usb.h>
 #include <linux/smp_lock.h>
@@ -117,12 +117,20 @@ static const char *format_endpt =
  * However, these will come from functions that return ptrs to each of them.
  */
 
-static DECLARE_WAIT_QUEUE_HEAD(deviceconndiscwq);
-static unsigned int conndiscevcnt;
-
-/* this struct stores the poll state for <mountpoint>/devices pollers */
-struct usb_device_status {
-        unsigned int lastev;
+/*
+ * Wait for an connect/disconnect event to happen. We initialize
+ * the event counter with an odd number, and each event will increment
+ * the event counter by two, so it will always _stay_ odd. That means
+ * that it will never be zero, so "event 0" will never match a current
+ * event, and thus 'poll' will always trigger as readable for the first
+ * time it gets called.
+ */
+static struct device_connect_event {
+        atomic_t count;
+        wait_queue_head_t wait;
+} device_event = {
+        .count = ATOMIC_INIT(1),
+        .wait = __WAIT_QUEUE_HEAD_INITIALIZER(device_event.wait)
 };
 
 struct class_info {
@@ -156,8 +164,8 @@ static const struct class_info clas_info[] =
 
 void usbfs_conn_disc_event(void)
 {
-        conndiscevcnt++;
-        wake_up(&deviceconndiscwq);
+        atomic_add(2, &device_event.count);
+        wake_up(&device_event.wait);
 }
 
 static const char *class_decode(const int class)
@@ -494,7 +502,7 @@ static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes,
                 return 0;
         /* allocate 2^1 pages = 8K (on i386);
          * should be more than enough for one device */
-        pages_start = (char *)__get_free_pages(GFP_KERNEL, 1);
+        pages_start = (char *)__get_free_pages(GFP_NOIO, 1);
         if (!pages_start)
                 return -ENOMEM;
 
@@ -629,55 +637,16 @@ static ssize_t usb_device_read(struct file *file, char __user *buf,
 static unsigned int usb_device_poll(struct file *file,
                                     struct poll_table_struct *wait)
 {
-        struct usb_device_status *st = file->private_data;
-        unsigned int mask = 0;
-
-        lock_kernel();
-        if (!st) {
-                st = kmalloc(sizeof(struct usb_device_status), GFP_KERNEL);
-
-                /* we may have dropped BKL -
-                 * need to check for having lost the race */
-                if (file->private_data) {
-                        kfree(st);
-                        st = file->private_data;
-                        goto lost_race;
-                }
-                /* we haven't lost - check for allocation failure now */
-                if (!st) {
-                        unlock_kernel();
-                        return POLLIN;
-                }
+        unsigned int event_count;
 
-                /*
-                 * need to prevent the module from being unloaded, since
-                 * proc_unregister does not call the release method and
-                 * we would have a memory leak
-                 */
-                st->lastev = conndiscevcnt;
-                file->private_data = st;
-                mask = POLLIN;
-        }
-lost_race:
-        if (file->f_mode & FMODE_READ)
-                poll_wait(file, &deviceconndiscwq, wait);
-        if (st->lastev != conndiscevcnt)
-                mask |= POLLIN;
-        st->lastev = conndiscevcnt;
-        unlock_kernel();
-        return mask;
-}
+        poll_wait(file, &device_event.wait, wait);
 
-static int usb_device_open(struct inode *inode, struct file *file)
-{
-        file->private_data = NULL;
-        return 0;
-}
+        event_count = atomic_read(&device_event.count);
+        if (file->f_version != event_count) {
+                file->f_version = event_count;
+                return POLLIN | POLLRDNORM;
+        }
 
-static int usb_device_release(struct inode *inode, struct file *file)
-{
-        kfree(file->private_data);
-        file->private_data = NULL;
         return 0;
 }
 
@@ -685,7 +654,7 @@ static loff_t usb_device_lseek(struct file *file, loff_t offset, int orig)
 {
         loff_t ret;
 
-        lock_kernel();
+        mutex_lock(&file->f_dentry->d_inode->i_mutex);
 
         switch (orig) {
         case 0:
@@ -701,7 +670,7 @@ static loff_t usb_device_lseek(struct file *file, loff_t offset, int orig)
                 ret = -EINVAL;
         }
 
-        unlock_kernel();
+        mutex_unlock(&file->f_dentry->d_inode->i_mutex);
         return ret;
 }
 
@@ -709,6 +678,4 @@ const struct file_operations usbfs_devices_fops = {
         .llseek =       usb_device_lseek,
         .read =         usb_device_read,
         .poll =         usb_device_poll,
-        .open =         usb_device_open,
-        .release =      usb_device_release,
 };
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 181f78c84105..3466fdc5bb11 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -122,7 +122,7 @@ static loff_t usbdev_lseek(struct file *file, loff_t offset, int orig)
 {
         loff_t ret;
 
-        lock_kernel();
+        mutex_lock(&file->f_dentry->d_inode->i_mutex);
 
         switch (orig) {
         case 0:
@@ -138,7 +138,7 @@ static loff_t usbdev_lseek(struct file *file, loff_t offset, int orig)
                 ret = -EINVAL;
         }
 
-        unlock_kernel();
+        mutex_unlock(&file->f_dentry->d_inode->i_mutex);
         return ret;
 }
 
@@ -310,7 +310,8 @@ static struct async *async_getpending(struct dev_state *ps,
 
 static void snoop_urb(struct usb_device *udev,
                 void __user *userurb, int pipe, unsigned length,
-                int timeout_or_status, enum snoop_when when)
+                int timeout_or_status, enum snoop_when when,
+                unsigned char *data, unsigned data_len)
 {
         static const char *types[] = {"isoc", "int", "ctrl", "bulk"};
         static const char *dirs[] = {"out", "in"};
@@ -344,6 +345,11 @@ static void snoop_urb(struct usb_device *udev,
                                         "status %d\n",
                                         ep, t, d, length, timeout_or_status);
         }
+
+        if (data && data_len > 0) {
+                print_hex_dump(KERN_DEBUG, "data: ", DUMP_PREFIX_NONE, 32, 1,
+                        data, data_len, 1);
+        }
 }
 
 #define AS_CONTINUATION 1
@@ -410,7 +416,9 @@ static void async_completed(struct urb *urb)
         }
         snoop(&urb->dev->dev, "urb complete\n");
         snoop_urb(urb->dev, as->userurb, urb->pipe, urb->actual_length,
-                        as->status, COMPLETE);
+                        as->status, COMPLETE,
+                        ((urb->transfer_flags & URB_DIR_MASK) == USB_DIR_OUT) ?
+                                NULL : urb->transfer_buffer, urb->actual_length);
         if (as->status < 0 && as->bulk_addr && as->status != -ECONNRESET &&
                         as->status != -ENOENT)
                 cancel_bulk_urbs(ps, as->bulk_addr);
@@ -653,20 +661,20 @@ static int usbdev_open(struct inode *inode, struct file *file)
         const struct cred *cred = current_cred();
         int ret;
 
-        lock_kernel();
-        /* Protect against simultaneous removal or release */
-        mutex_lock(&usbfs_mutex);
-
         ret = -ENOMEM;
         ps = kmalloc(sizeof(struct dev_state), GFP_KERNEL);
         if (!ps)
-                goto out;
+                goto out_free_ps;
 
         ret = -ENODEV;
 
+        /* Protect against simultaneous removal or release */
+        mutex_lock(&usbfs_mutex);
+
         /* usbdev device-node */
         if (imajor(inode) == USB_DEVICE_MAJOR)
                 dev = usbdev_lookup_by_devt(inode->i_rdev);
+
 #ifdef CONFIG_USB_DEVICEFS
         /* procfs file */
         if (!dev) {
@@ -678,13 +686,19 @@ static int usbdev_open(struct inode *inode, struct file *file)
                         dev = NULL;
         }
 #endif
-        if (!dev || dev->state == USB_STATE_NOTATTACHED)
-                goto out;
+        mutex_unlock(&usbfs_mutex);
+
+        if (!dev)
+                goto out_free_ps;
+
+        usb_lock_device(dev);
+        if (dev->state == USB_STATE_NOTATTACHED)
+                goto out_unlock_device;
+
         ret = usb_autoresume_device(dev);
         if (ret)
-                goto out;
+                goto out_unlock_device;
 
-        ret = 0;
         ps->dev = dev;
         ps->file = file;
         spin_lock_init(&ps->lock);
@@ -702,15 +716,16 @@ static int usbdev_open(struct inode *inode, struct file *file)
         smp_wmb();
         list_add_tail(&ps->list, &dev->filelist);
         file->private_data = ps;
+        usb_unlock_device(dev);
         snoop(&dev->dev, "opened by process %d: %s\n", task_pid_nr(current),
                         current->comm);
- out:
-        if (ret) {
-                kfree(ps);
-                usb_put_dev(dev);
-        }
-        mutex_unlock(&usbfs_mutex);
-        unlock_kernel();
+        return ret;
+
+ out_unlock_device:
+        usb_unlock_device(dev);
+        usb_put_dev(dev);
+ out_free_ps:
+        kfree(ps);
         return ret;
 }
 
@@ -724,10 +739,7 @@ static int usbdev_release(struct inode *inode, struct file *file)
         usb_lock_device(dev);
         usb_hub_release_all_ports(dev, ps);
 
-        /* Protect against simultaneous open */
-        mutex_lock(&usbfs_mutex);
         list_del_init(&ps->list);
-        mutex_unlock(&usbfs_mutex);
 
         for (ifnum = 0; ps->ifclaimed && ifnum < 8*sizeof(ps->ifclaimed);
                         ifnum++) {
@@ -770,6 +782,13 @@ static int proc_control(struct dev_state *ps, void __user *arg)
         if (!tbuf)
                 return -ENOMEM;
         tmo = ctrl.timeout;
+        snoop(&dev->dev, "control urb: bRequestType=%02x "
+                "bRequest=%02x wValue=%04x "
+                "wIndex=%04x wLength=%04x\n",
+                ctrl.bRequestType, ctrl.bRequest,
+                __le16_to_cpup(&ctrl.wValue),
+                __le16_to_cpup(&ctrl.wIndex),
+                __le16_to_cpup(&ctrl.wLength));
         if (ctrl.bRequestType & 0x80) {
                 if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data,
                                                ctrl.wLength)) {
@@ -777,15 +796,15 @@ static int proc_control(struct dev_state *ps, void __user *arg)
                         return -EINVAL;
                 }
                 pipe = usb_rcvctrlpipe(dev, 0);
-                snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT);
+                snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, NULL, 0);
 
                 usb_unlock_device(dev);
                 i = usb_control_msg(dev, pipe, ctrl.bRequest,
                                     ctrl.bRequestType, ctrl.wValue, ctrl.wIndex,
                                     tbuf, ctrl.wLength, tmo);
                 usb_lock_device(dev);
-                snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE);
-
+                snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE,
+                        tbuf, i);
                 if ((i > 0) && ctrl.wLength) {
                         if (copy_to_user(ctrl.data, tbuf, i)) {
                                 free_page((unsigned long)tbuf);
@@ -800,14 +819,15 @@ static int proc_control(struct dev_state *ps, void __user *arg)
                         }
                 }
                 pipe = usb_sndctrlpipe(dev, 0);
-                snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT);
+                snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT,
+                        tbuf, ctrl.wLength);
 
                 usb_unlock_device(dev);
                 i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest,
                                     ctrl.bRequestType, ctrl.wValue, ctrl.wIndex,
                                     tbuf, ctrl.wLength, tmo);
                 usb_lock_device(dev);
-                snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE);
+                snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE, NULL, 0);
         }
         free_page((unsigned long)tbuf);
         if (i < 0 && i != -EPIPE) {
@@ -853,12 +873,12 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
                         kfree(tbuf);
                         return -EINVAL;
                 }
-                snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT);
+                snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT, NULL, 0);
 
                 usb_unlock_device(dev);
                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
                 usb_lock_device(dev);
-                snoop_urb(dev, NULL, pipe, len2, i, COMPLETE);
+                snoop_urb(dev, NULL, pipe, len2, i, COMPLETE, tbuf, len2);
 
                 if (!i && len2) {
                         if (copy_to_user(bulk.data, tbuf, len2)) {
@@ -873,12 +893,12 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
                                 return -EFAULT;
                         }
                 }
-                snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT);
+                snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT, tbuf, len1);
 
                 usb_unlock_device(dev);
                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
                 usb_lock_device(dev);
-                snoop_urb(dev, NULL, pipe, len2, i, COMPLETE);
+                snoop_urb(dev, NULL, pipe, len2, i, COMPLETE, NULL, 0);
         }
         kfree(tbuf);
         if (i < 0)
@@ -1097,6 +1117,13 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         is_in = 0;
                         uurb->endpoint &= ~USB_DIR_IN;
                 }
+                snoop(&ps->dev->dev, "control urb: bRequestType=%02x "
+                        "bRequest=%02x wValue=%04x "
+                        "wIndex=%04x wLength=%04x\n",
+                        dr->bRequestType, dr->bRequest,
+                        __le16_to_cpup(&dr->wValue),
+                        __le16_to_cpup(&dr->wIndex),
+                        __le16_to_cpup(&dr->wLength));
                 break;
 
         case USBDEVFS_URB_TYPE_BULK:
@@ -1104,13 +1131,25 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 case USB_ENDPOINT_XFER_CONTROL:
                 case USB_ENDPOINT_XFER_ISOC:
                         return -EINVAL;
-                /* allow single-shot interrupt transfers, at bogus rates */
+                case USB_ENDPOINT_XFER_INT:
+                        /* allow single-shot interrupt transfers */
+                        uurb->type = USBDEVFS_URB_TYPE_INTERRUPT;
+                        goto interrupt_urb;
                 }
                 uurb->number_of_packets = 0;
                 if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
                         return -EINVAL;
                 break;
 
+        case USBDEVFS_URB_TYPE_INTERRUPT:
+                if (!usb_endpoint_xfer_int(&ep->desc))
+                        return -EINVAL;
+ interrupt_urb:
+                uurb->number_of_packets = 0;
+                if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
+                        return -EINVAL;
+                break;
+
         case USBDEVFS_URB_TYPE_ISO:
                 /* arbitrary limit */
                 if (uurb->number_of_packets < 1 ||
@@ -1143,14 +1182,6 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 uurb->buffer_length = totlen;
                 break;
 
-        case USBDEVFS_URB_TYPE_INTERRUPT:
-                uurb->number_of_packets = 0;
-                if (!usb_endpoint_xfer_int(&ep->desc))
-                        return -EINVAL;
-                if (uurb->buffer_length > MAX_USBFS_BUFFER_SIZE)
-                        return -EINVAL;
-                break;
-
         default:
                 return -EINVAL;
         }
@@ -1176,6 +1207,13 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         free_async(as);
                         return -ENOMEM;
                 }
+                /* Isochronous input data may end up being discontiguous
+                 * if some of the packets are short.  Clear the buffer so
+                 * that the gaps don't leak kernel data to userspace.
+                 */
+                if (is_in && uurb->type == USBDEVFS_URB_TYPE_ISO)
+                        memset(as->urb->transfer_buffer, 0,
+                                        uurb->buffer_length);
         }
         as->urb->dev = ps->dev;
         as->urb->pipe = (uurb->type << 30) |
@@ -1236,7 +1274,9 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 }
         }
         snoop_urb(ps->dev, as->userurb, as->urb->pipe,
-                        as->urb->transfer_buffer_length, 0, SUBMIT);
+                        as->urb->transfer_buffer_length, 0, SUBMIT,
+                        is_in ? NULL : as->urb->transfer_buffer,
+                                uurb->buffer_length);
         async_newpending(as);
 
         if (usb_endpoint_xfer_bulk(&ep->desc)) {
@@ -1274,7 +1314,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 dev_printk(KERN_DEBUG, &ps->dev->dev,
                            "usbfs: usb_submit_urb returned %d\n", ret);
                 snoop_urb(ps->dev, as->userurb, as->urb->pipe,
-                                0, ret, COMPLETE);
+                                0, ret, COMPLETE, NULL, 0);
                 async_removepending(as);
                 free_async(as);
                 return ret;
@@ -1312,10 +1352,14 @@ static int processcompl(struct async *as, void __user * __user *arg)
         void __user *addr = as->userurb;
         unsigned int i;
 
-        if (as->userbuffer)
-                if (copy_to_user(as->userbuffer, urb->transfer_buffer,
-                                 urb->transfer_buffer_length))
+        if (as->userbuffer && urb->actual_length) {
+                if (urb->number_of_packets > 0)         /* Isochronous */
+                        i = urb->transfer_buffer_length;
+                else                                    /* Non-Isoc */
+                        i = urb->actual_length;
+                if (copy_to_user(as->userbuffer, urb->transfer_buffer, i))
                         goto err_out;
+        }
         if (put_user(as->status, &userurb->status))
                 goto err_out;
         if (put_user(urb->actual_length, &userurb->actual_length))
@@ -1334,14 +1378,11 @@ static int processcompl(struct async *as, void __user * __user *arg)
                 }
         }
 
-        free_async(as);
-
         if (put_user(addr, (void __user * __user *)arg))
                 return -EFAULT;
         return 0;
 
 err_out:
-        free_async(as);
         return -EFAULT;
 }
 
@@ -1371,8 +1412,11 @@ static struct async *reap_as(struct dev_state *ps)
 static int proc_reapurb(struct dev_state *ps, void __user *arg)
 {
         struct async *as = reap_as(ps);
-        if (as)
-                return processcompl(as, (void __user * __user *)arg);
+        if (as) {
+                int retval = processcompl(as, (void __user * __user *)arg);
+                free_async(as);
+                return retval;
+        }
         if (signal_pending(current))
                 return -EINTR;
         return -EIO;
@@ -1380,14 +1424,59 @@ static int proc_reapurb(struct dev_state *ps, void __user *arg)
 
 static int proc_reapurbnonblock(struct dev_state *ps, void __user *arg)
 {
+        int retval;
         struct async *as;
 
-        if (!(as = async_getcompleted(ps)))
-                return -EAGAIN;
-        return processcompl(as, (void __user * __user *)arg);
+        as = async_getcompleted(ps);
+        retval = -EAGAIN;
+        if (as) {
+                retval = processcompl(as, (void __user * __user *)arg);
+                free_async(as);
+        }
+        return retval;
 }
 
 #ifdef CONFIG_COMPAT
+static int proc_control_compat(struct dev_state *ps,
+                                struct usbdevfs_ctrltransfer32 __user *p32)
+{
+        struct usbdevfs_ctrltransfer __user *p;
+        __u32 udata;
+        p = compat_alloc_user_space(sizeof(*p));
+        if (copy_in_user(p, p32, (sizeof(*p32) - sizeof(compat_caddr_t))) ||
+            get_user(udata, &p32->data) ||
+            put_user(compat_ptr(udata), &p->data))
+                return -EFAULT;
+        return proc_control(ps, p);
+}
+
+static int proc_bulk_compat(struct dev_state *ps,
+                        struct usbdevfs_bulktransfer32 __user *p32)
+{
+        struct usbdevfs_bulktransfer __user *p;
+        compat_uint_t n;
+        compat_caddr_t addr;
+
+        p = compat_alloc_user_space(sizeof(*p));
+
+        if (get_user(n, &p32->ep) || put_user(n, &p->ep) ||
+            get_user(n, &p32->len) || put_user(n, &p->len) ||
+            get_user(n, &p32->timeout) || put_user(n, &p->timeout) ||
+            get_user(addr, &p32->data) || put_user(compat_ptr(addr), &p->data))
+                return -EFAULT;
+
+        return proc_bulk(ps, p);
+}
+static int proc_disconnectsignal_compat(struct dev_state *ps, void __user *arg)
+{
+        struct usbdevfs_disconnectsignal32 ds;
+
+        if (copy_from_user(&ds, arg, sizeof(ds)))
+                return -EFAULT;
+        ps->discsignr = ds.signr;
+        ps->disccontext = compat_ptr(ds.context);
+        return 0;
+}
 
 static int get_urb32(struct usbdevfs_urb *kurb,
                      struct usbdevfs_urb32 __user *uurb)
@@ -1435,9 +1524,9 @@ static int processcompl_compat(struct async *as, void __user * __user *arg)
         void __user *addr = as->userurb;
         unsigned int i;
 
-        if (as->userbuffer)
+        if (as->userbuffer && urb->actual_length)
                 if (copy_to_user(as->userbuffer, urb->transfer_buffer,
-                                 urb->transfer_buffer_length))
+                                 urb->actual_length))
                         return -EFAULT;
         if (put_user(as->status, &userurb->status))
                 return -EFAULT;
@@ -1457,7 +1546,6 @@ static int processcompl_compat(struct async *as, void __user * __user *arg)
                 }
         }
 
-        free_async(as);
         if (put_user(ptr_to_compat(addr), (u32 __user *)arg))
                 return -EFAULT;
         return 0;
@@ -1466,8 +1554,11 @@ static int processcompl_compat(struct async *as, void __user * __user *arg)
 static int proc_reapurb_compat(struct dev_state *ps, void __user *arg)
 {
         struct async *as = reap_as(ps);
-        if (as)
-                return processcompl_compat(as, (void __user * __user *)arg);
+        if (as) {
+                int retval = processcompl_compat(as, (void __user * __user *)arg);
+                free_async(as);
+                return retval;
+        }
         if (signal_pending(current))
                 return -EINTR;
         return -EIO;
@@ -1475,13 +1566,19 @@ static int proc_reapurb_compat(struct dev_state *ps, void __user *arg)
 
 static int proc_reapurbnonblock_compat(struct dev_state *ps, void __user *arg)
 {
+        int retval;
         struct async *as;
 
-        if (!(as = async_getcompleted(ps)))
-                return -EAGAIN;
-        return processcompl_compat(as, (void __user * __user *)arg);
+        retval = -EAGAIN;
+        as = async_getcompleted(ps);
+        if (as) {
+                retval = processcompl_compat(as, (void __user * __user *)arg);
+                free_async(as);
+        }
+        return retval;
 }
 
+
 #endif
 
 static int proc_disconnectsignal(struct dev_state *ps, void __user *arg)
@@ -1575,7 +1672,10 @@ static int proc_ioctl(struct dev_state *ps, struct usbdevfs_ioctl *ctl)
                 if (driver == NULL || driver->ioctl == NULL) {
                         retval = -ENOTTY;
                 } else {
+                        /* keep API that guarantees BKL */
+                        lock_kernel();
                         retval = driver->ioctl(intf, ctl->ioctl_code, buf);
+                        unlock_kernel();
                         if (retval == -ENOIOCTLCMD)
                                 retval = -ENOTTY;
                 }
@@ -1648,16 +1748,17 @@ static int proc_release_port(struct dev_state *ps, void __user *arg)
  * are assuming that somehow the configuration has been prevented from
  * changing.  But there's no mechanism to ensure that...
  */
-static int usbdev_ioctl(struct inode *inode, struct file *file,
-                        unsigned int cmd, unsigned long arg)
+static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
+                                void __user *p)
 {
         struct dev_state *ps = file->private_data;
+        struct inode *inode = file->f_path.dentry->d_inode;
         struct usb_device *dev = ps->dev;
-        void __user *p = (void __user *)arg;
         int ret = -ENOTTY;
 
         if (!(file->f_mode & FMODE_WRITE))
                 return -EPERM;
+
         usb_lock_device(dev);
         if (!connected(ps)) {
                 usb_unlock_device(dev);
@@ -1726,6 +1827,24 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
                 break;
 
 #ifdef CONFIG_COMPAT
+        case USBDEVFS_CONTROL32:
+                snoop(&dev->dev, "%s: CONTROL32\n", __func__);
+                ret = proc_control_compat(ps, p);
+                if (ret >= 0)
+                        inode->i_mtime = CURRENT_TIME;
+                break;
+
+        case USBDEVFS_BULK32:
+                snoop(&dev->dev, "%s: BULK32\n", __func__);
+                ret = proc_bulk_compat(ps, p);
+                if (ret >= 0)
+                        inode->i_mtime = CURRENT_TIME;
+                break;
+
+        case USBDEVFS_DISCSIGNAL32:
+                snoop(&dev->dev, "%s: DISCSIGNAL32\n", __func__);
+                ret = proc_disconnectsignal_compat(ps, p);
+                break;
 
         case USBDEVFS_SUBMITURB32:
                 snoop(&dev->dev, "%s: SUBMITURB32\n", __func__);
@@ -1745,7 +1864,7 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
                 break;
 
         case USBDEVFS_IOCTL32:
-                snoop(&dev->dev, "%s: IOCTL\n", __func__);
+                snoop(&dev->dev, "%s: IOCTL32\n", __func__);
                 ret = proc_ioctl_compat(ps, ptr_to_compat(p));
                 break;
 #endif
@@ -1801,6 +1920,28 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
         return ret;
 }
 
+static long usbdev_ioctl(struct file *file, unsigned int cmd,
+                        unsigned long arg)
+{
+        int ret;
+
+        ret = usbdev_do_ioctl(file, cmd, (void __user *)arg);
+
+        return ret;
+}
+
+#ifdef CONFIG_COMPAT
+static long usbdev_compat_ioctl(struct file *file, unsigned int cmd,
+                        unsigned long arg)
+{
+        int ret;
+
+        ret = usbdev_do_ioctl(file, cmd, compat_ptr(arg));
+
+        return ret;
+}
+#endif
+
 /* No kernel lock - fine */
 static unsigned int usbdev_poll(struct file *file,
                                 struct poll_table_struct *wait)
@@ -1817,13 +1958,16 @@ static unsigned int usbdev_poll(struct file *file,
 }
 
 const struct file_operations usbdev_file_operations = {
-        .owner =        THIS_MODULE,
-        .llseek =       usbdev_lseek,
-        .read =         usbdev_read,
-        .poll =         usbdev_poll,
-        .ioctl =        usbdev_ioctl,
-        .open =         usbdev_open,
-        .release =      usbdev_release,
+        .owner =          THIS_MODULE,
+        .llseek =         usbdev_lseek,
+        .read =           usbdev_read,
+        .poll =           usbdev_poll,
+        .unlocked_ioctl = usbdev_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl =   usbdev_compat_ioctl,
+#endif
+        .open =           usbdev_open,
+        .release =        usbdev_release,
 };
 
 static void usbdev_remove(struct usb_device *udev)
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 4f864472c5c4..2f3dc4cdf79b 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -23,9 +23,10 @@
  */
 
 #include <linux/device.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/usb/quirks.h>
-#include <linux/workqueue.h>
+#include <linux/pm_runtime.h>
 #include "hcd.h"
 #include "usb.h"
 
@@ -83,6 +84,47 @@ static ssize_t store_new_id(struct device_driver *driver,
 }
 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 
+/**
+ * store_remove_id - remove a USB device ID from this driver
+ * @driver: target device driver
+ * @buf: buffer for scanning device ID data
+ * @count: input size
+ *
+ * Removes a dynamic usb device ID from this driver.
+ */
+static ssize_t
+store_remove_id(struct device_driver *driver, const char *buf, size_t count)
+{
+        struct usb_dynid *dynid, *n;
+        struct usb_driver *usb_driver = to_usb_driver(driver);
+        u32 idVendor = 0;
+        u32 idProduct = 0;
+        int fields = 0;
+        int retval = 0;
+
+        fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
+        if (fields < 2)
+                return -EINVAL;
+
+        spin_lock(&usb_driver->dynids.lock);
+        list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) {
+                struct usb_device_id *id = &dynid->id;
+                if ((id->idVendor == idVendor) &&
+                    (id->idProduct == idProduct)) {
+                        list_del(&dynid->node);
+                        kfree(dynid);
+                        retval = 0;
+                        break;
+                }
+        }
+        spin_unlock(&usb_driver->dynids.lock);
+
+        if (retval)
+                return retval;
+        return count;
+}
+static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
+
 static int usb_create_newid_file(struct usb_driver *usb_drv)
 {
         int error = 0;
@@ -107,6 +149,21 @@ static void usb_remove_newid_file(struct usb_driver *usb_drv)
                                    &driver_attr_new_id);
 }
 
+static int
+usb_create_removeid_file(struct usb_driver *drv)
+{
+        int error = 0;
+        if (drv->probe != NULL)
+                error = driver_create_file(&drv->drvwrap.driver,
+                                &driver_attr_remove_id);
+        return error;
+}
+
+static void usb_remove_removeid_file(struct usb_driver *drv)
+{
+        driver_remove_file(&drv->drvwrap.driver, &driver_attr_remove_id);
+}
+
 static void usb_free_dynids(struct usb_driver *usb_drv)
 {
         struct usb_dynid *dynid, *n;
@@ -128,6 +185,16 @@ static void usb_remove_newid_file(struct usb_driver *usb_drv)
 {
 }
 
+static int
+usb_create_removeid_file(struct usb_driver *drv)
+{
+        return 0;
+}
+
+static void usb_remove_removeid_file(struct usb_driver *drv)
+{
+}
+
 static inline void usb_free_dynids(struct usb_driver *usb_drv)
 {
 }
@@ -155,7 +222,7 @@ static int usb_probe_device(struct device *dev)
 {
         struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
         struct usb_device *udev = to_usb_device(dev);
-        int error = -ENODEV;
+        int error = 0;
 
         dev_dbg(dev, "%s\n", __func__);
 
@@ -164,18 +231,23 @@ static int usb_probe_device(struct device *dev)
         /* The device should always appear to be in use
          * unless the driver suports autosuspend.
          */
-        udev->pm_usage_cnt = !(udriver->supports_autosuspend);
+        if (!udriver->supports_autosuspend)
+                error = usb_autoresume_device(udev);
 
-        error = udriver->probe(udev);
+        if (!error)
+                error = udriver->probe(udev);
         return error;
 }
 
 /* called from driver core with dev locked */
 static int usb_unbind_device(struct device *dev)
 {
+        struct usb_device *udev = to_usb_device(dev);
         struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
 
-        udriver->disconnect(to_usb_device(dev));
+        udriver->disconnect(udev);
+        if (!udriver->supports_autosuspend)
+                usb_autosuspend_device(udev);
         return 0;
 }
 
@@ -208,60 +280,62 @@ static int usb_probe_interface(struct device *dev)
         intf->needs_binding = 0;
 
         if (usb_device_is_owned(udev))
-                return -ENODEV;
+                return error;
 
         if (udev->authorized == 0) {
                 dev_err(&intf->dev, "Device is not authorized for usage\n");
-                return -ENODEV;
+                return error;
         }
 
         id = usb_match_id(intf, driver->id_table);
         if (!id)
                 id = usb_match_dynamic_id(intf, driver);
-        if (id) {
-                dev_dbg(dev, "%s - got id\n", __func__);
-
-                error = usb_autoresume_device(udev);
-                if (error)
-                        return error;
-
-                /* Interface "power state" doesn't correspond to any hardware
-                 * state whatsoever.  We use it to record when it's bound to
-                 * a driver that may start I/0:  it's not frozen/quiesced.
-                 */
-                mark_active(intf);
-                intf->condition = USB_INTERFACE_BINDING;
+        if (!id)
+                return error;
 
-                /* The interface should always appear to be in use
-                 * unless the driver suports autosuspend.
-                 */
-                atomic_set(&intf->pm_usage_cnt, !driver->supports_autosuspend);
+        dev_dbg(dev, "%s - got id\n", __func__);
 
-                /* Carry out a deferred switch to altsetting 0 */
-                if (intf->needs_altsetting0) {
-                        error = usb_set_interface(udev, intf->altsetting[0].
-                                        desc.bInterfaceNumber, 0);
-                        if (error < 0)
-                                goto err;
+        error = usb_autoresume_device(udev);
+        if (error)
+                return error;
 
-                        intf->needs_altsetting0 = 0;
-                }
+        intf->condition = USB_INTERFACE_BINDING;
 
-                error = driver->probe(intf, id);
-                if (error)
+        /* Probed interfaces are initially active.  They are
+         * runtime-PM-enabled only if the driver has autosuspend support.
+         * They are sensitive to their children's power states.
+         */
+        pm_runtime_set_active(dev);
+        pm_suspend_ignore_children(dev, false);
+        if (driver->supports_autosuspend)
+                pm_runtime_enable(dev);
+
+        /* Carry out a deferred switch to altsetting 0 */
+        if (intf->needs_altsetting0) {
+                error = usb_set_interface(udev, intf->altsetting[0].
+                                desc.bInterfaceNumber, 0);
+                if (error < 0)
                         goto err;
-
-                intf->condition = USB_INTERFACE_BOUND;
-                usb_autosuspend_device(udev);
+                intf->needs_altsetting0 = 0;
         }
 
+        error = driver->probe(intf, id);
+        if (error)
+                goto err;
+
+        intf->condition = USB_INTERFACE_BOUND;
+        usb_autosuspend_device(udev);
         return error;
 
-err:
-        mark_quiesced(intf);
+ err:
         intf->needs_remote_wakeup = 0;
         intf->condition = USB_INTERFACE_UNBOUND;
         usb_cancel_queued_reset(intf);
+
+        /* Unbound interfaces are always runtime-PM-disabled and -suspended */
+        pm_runtime_disable(dev);
+        pm_runtime_set_suspended(dev);
+
         usb_autosuspend_device(udev);
         return error;
 }
@@ -311,9 +385,17 @@ static int usb_unbind_interface(struct device *dev)
         usb_set_intfdata(intf, NULL);
 
         intf->condition = USB_INTERFACE_UNBOUND;
-        mark_quiesced(intf);
         intf->needs_remote_wakeup = 0;
 
+        /* Unbound interfaces are always runtime-PM-disabled and -suspended */
+        pm_runtime_disable(dev);
+        pm_runtime_set_suspended(dev);
+
+        /* Undo any residual pm_autopm_get_interface_* calls */
+        for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r)
+                usb_autopm_put_interface_no_suspend(intf);
+        atomic_set(&intf->pm_usage_cnt, 0);
+
         if (!error)
                 usb_autosuspend_device(udev);
 
@@ -344,7 +426,6 @@ int usb_driver_claim_interface(struct usb_driver *driver,
                                 struct usb_interface *iface, void *priv)
 {
         struct device *dev = &iface->dev;
-        struct usb_device *udev = interface_to_usbdev(iface);
         int retval = 0;
 
         if (dev->driver)
@@ -354,11 +435,16 @@ int usb_driver_claim_interface(struct usb_driver *driver,
         usb_set_intfdata(iface, priv);
         iface->needs_binding = 0;
 
-        usb_pm_lock(udev);
         iface->condition = USB_INTERFACE_BOUND;
-        mark_active(iface);
-        atomic_set(&iface->pm_usage_cnt, !driver->supports_autosuspend);
-        usb_pm_unlock(udev);
+
+        /* Claimed interfaces are initially inactive (suspended).  They are
+         * runtime-PM-enabled only if the driver has autosuspend support.
+         * They are sensitive to their children's power states.
+         */
+        pm_runtime_set_suspended(dev);
+        pm_suspend_ignore_children(dev, false);
+        if (driver->supports_autosuspend)
+                pm_runtime_enable(dev);
 
         /* if interface was already added, bind now; else let
          * the future device_add() bind it, bypassing probe()
@@ -404,10 +490,10 @@ void usb_driver_release_interface(struct usb_driver *driver,
         if (device_is_registered(dev)) {
                 device_release_driver(dev);
         } else {
-                down(&dev->sem);
+                device_lock(dev);
                 usb_unbind_interface(dev);
                 dev->driver = NULL;
-                up(&dev->sem);
+                device_unlock(dev);
         }
 }
 EXPORT_SYMBOL_GPL(usb_driver_release_interface);
@@ -625,9 +711,6 @@ static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct usb_device *usb_dev;
 
-        /* driver is often null here; dev_dbg() would oops */
-        pr_debug("usb %s: uevent\n", dev_name(dev));
-
         if (is_usb_device(dev)) {
                 usb_dev = to_usb_device(dev);
         } else if (is_usb_interface(dev)) {
@@ -639,6 +722,7 @@ static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
         }
 
         if (usb_dev->devnum < 0) {
+                /* driver is often null here; dev_dbg() would oops */
                 pr_debug("usb %s: already deleted?\n", dev_name(dev));
                 return -ENODEV;
         }
@@ -774,19 +858,34 @@ int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
         INIT_LIST_HEAD(&new_driver->dynids.list);
 
         retval = driver_register(&new_driver->drvwrap.driver);
+        if (retval)
+                goto out;
 
-        if (!retval) {
-                pr_info("%s: registered new interface driver %s\n",
+        usbfs_update_special();
+
+        retval = usb_create_newid_file(new_driver);
+        if (retval)
+                goto out_newid;
+
+        retval = usb_create_removeid_file(new_driver);
+        if (retval)
+                goto out_removeid;
+
+        pr_info("%s: registered new interface driver %s\n",
                         usbcore_name, new_driver->name);
-                usbfs_update_special();
-                usb_create_newid_file(new_driver);
-        } else {
-                printk(KERN_ERR "%s: error %d registering interface "
-                        "       driver %s\n",
-                        usbcore_name, retval, new_driver->name);
-        }
 
+out:
         return retval;
+
+out_removeid:
+        usb_remove_newid_file(new_driver);
+out_newid:
+        driver_unregister(&new_driver->drvwrap.driver);
+
+        printk(KERN_ERR "%s: error %d registering interface "
+                        "       driver %s\n",
+                        usbcore_name, retval, new_driver->name);
+        goto out;
 }
 EXPORT_SYMBOL_GPL(usb_register_driver);
 
@@ -806,6 +905,7 @@ void usb_deregister(struct usb_driver *driver)
         pr_info("%s: deregistering interface driver %s\n",
                         usbcore_name, driver->name);
 
+        usb_remove_removeid_file(driver);
         usb_remove_newid_file(driver);
         usb_free_dynids(driver);
         driver_unregister(&driver->drvwrap.driver);
@@ -901,7 +1001,6 @@ static void do_unbind_rebind(struct usb_device *udev, int action)
         }
 }
 
-/* Caller has locked udev's pm_mutex */
 static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
 {
         struct usb_device_driver        *udriver;
@@ -925,7 +1024,6 @@ static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
         return status;
 }
 
-/* Caller has locked udev's pm_mutex */
 static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
 {
         struct usb_device_driver        *udriver;
@@ -940,6 +1038,14 @@ static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
                 goto done;
         }
 
+        /* Non-root devices on a full/low-speed bus must wait for their
+         * companion high-speed root hub, in case a handoff is needed.
+         */
+        if (!(msg.event & PM_EVENT_AUTO) && udev->parent &&
+                        udev->bus->hs_companion)
+                device_pm_wait_for_dev(&udev->dev,
+                                &udev->bus->hs_companion->root_hub->dev);
+
         if (udev->quirks & USB_QUIRK_RESET_RESUME)
                 udev->reset_resume = 1;
 
@@ -948,32 +1054,23 @@ static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
 
  done:
         dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
-        if (status == 0)
-                udev->autoresume_disabled = 0;
         return status;
 }
 
-/* Caller has locked intf's usb_device's pm mutex */
 static int usb_suspend_interface(struct usb_device *udev,
                 struct usb_interface *intf, pm_message_t msg)
 {
         struct usb_driver       *driver;
         int                     status = 0;
 
-        /* with no hardware, USB interfaces only use FREEZE and ON states */
-        if (udev->state == USB_STATE_NOTATTACHED || !is_active(intf))
-                goto done;
-
-        /* This can happen; see usb_driver_release_interface() */
-        if (intf->condition == USB_INTERFACE_UNBOUND)
+        if (udev->state == USB_STATE_NOTATTACHED ||
+                        intf->condition == USB_INTERFACE_UNBOUND)
                 goto done;
         driver = to_usb_driver(intf->dev.driver);
 
         if (driver->suspend) {
                 status = driver->suspend(intf, msg);
-                if (status == 0)
-                        mark_quiesced(intf);
-                else if (!(msg.event & PM_EVENT_AUTO))
+                if (status && !(msg.event & PM_EVENT_AUTO))
                         dev_err(&intf->dev, "%s error %d\n",
                                         "suspend", status);
         } else {
@@ -981,7 +1078,6 @@ static int usb_suspend_interface(struct usb_device *udev,
                 intf->needs_binding = 1;
                 dev_warn(&intf->dev, "no %s for driver %s?\n",
                                 "suspend", driver->name);
-                mark_quiesced(intf);
         }
 
  done:
@@ -989,14 +1085,13 @@ static int usb_suspend_interface(struct usb_device *udev,
         return status;
 }
 
-/* Caller has locked intf's usb_device's pm_mutex */
 static int usb_resume_interface(struct usb_device *udev,
                 struct usb_interface *intf, pm_message_t msg, int reset_resume)
 {
         struct usb_driver       *driver;
         int                     status = 0;
 
-        if (udev->state == USB_STATE_NOTATTACHED || is_active(intf))
+        if (udev->state == USB_STATE_NOTATTACHED)
                 goto done;
 
         /* Don't let autoresume interfere with unbinding */
@@ -1047,90 +1142,11 @@ static int usb_resume_interface(struct usb_device *udev,
 
 done:
         dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
-        if (status == 0 && intf->condition == USB_INTERFACE_BOUND)
-                mark_active(intf);
 
         /* Later we will unbind the driver and/or reprobe, if necessary */
         return status;
 }
 
-#ifdef  CONFIG_USB_SUSPEND
-
-/* Internal routine to check whether we may autosuspend a device. */
-static int autosuspend_check(struct usb_device *udev, int reschedule)
-{
-        int                     i;
-        struct usb_interface    *intf;
-        unsigned long           suspend_time, j;
-
-        /* For autosuspend, fail fast if anything is in use or autosuspend
-         * is disabled.  Also fail if any interfaces require remote wakeup
-         * but it isn't available.
-         */
-        if (udev->pm_usage_cnt > 0)
-                return -EBUSY;
-        if (udev->autosuspend_delay < 0 || udev->autosuspend_disabled)
-                return -EPERM;
-
-        suspend_time = udev->last_busy + udev->autosuspend_delay;
-        if (udev->actconfig) {
-                for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
-                        intf = udev->actconfig->interface[i];
-                        if (!is_active(intf))
-                                continue;
-                        if (atomic_read(&intf->pm_usage_cnt) > 0)
-                                return -EBUSY;
-                        if (intf->needs_remote_wakeup &&
-                                        !udev->do_remote_wakeup) {
-                                dev_dbg(&udev->dev, "remote wakeup needed "
-                                                "for autosuspend\n");
-                                return -EOPNOTSUPP;
-                        }
-
-                        /* Don't allow autosuspend if the device will need
-                         * a reset-resume and any of its interface drivers
-                         * doesn't include support.
-                         */
-                        if (udev->quirks & USB_QUIRK_RESET_RESUME) {
-                                struct usb_driver *driver;
-
-                                driver = to_usb_driver(intf->dev.driver);
-                                if (!driver->reset_resume ||
-                                    intf->needs_remote_wakeup)
-                                        return -EOPNOTSUPP;
-                        }
-                }
-        }
-
-        /* If everything is okay but the device hasn't been idle for long
-         * enough, queue a delayed autosuspend request.  If the device
-         * _has_ been idle for long enough and the reschedule flag is set,
-         * likewise queue a delayed (1 second) autosuspend request.
-         */
-        j = jiffies;
-        if (time_before(j, suspend_time))
-                reschedule = 1;
-        else
-                suspend_time = j + HZ;
-        if (reschedule) {
-                if (!timer_pending(&udev->autosuspend.timer)) {
-                        queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
-                                round_jiffies_up_relative(suspend_time - j));
-                }
-                return -EAGAIN;
-        }
-        return 0;
-}
-
-#else
-
-static inline int autosuspend_check(struct usb_device *udev, int reschedule)
-{
-        return 0;
-}
-
-#endif  /* CONFIG_USB_SUSPEND */
-
 /**
  * usb_suspend_both - suspend a USB device and its interfaces
  * @udev: the usb_device to suspend
@@ -1142,52 +1158,29 @@ static inline int autosuspend_check(struct usb_device *udev, int reschedule)
  * all the interfaces which were suspended are resumed so that they remain
  * in the same state as the device.
  *
- * If an autosuspend is in progress the routine checks first to make sure
- * that neither the device itself or any of its active interfaces is in use
- * (pm_usage_cnt is greater than 0).  If they are, the autosuspend fails.
- *
- * If the suspend succeeds, the routine recursively queues an autosuspend
- * request for @udev's parent device, thereby propagating the change up
- * the device tree.  If all of the parent's children are now suspended,
- * the parent will autosuspend in turn.
- *
- * The suspend method calls are subject to mutual exclusion under control
- * of @udev's pm_mutex.  Many of these calls are also under the protection
- * of @udev's device lock (including all requests originating outside the
- * USB subsystem), but autosuspend requests generated by a child device or
- * interface driver may not be.  Usbcore will insure that the method calls
- * do not arrive during bind, unbind, or reset operations.  However, drivers
- * must be prepared to handle suspend calls arriving at unpredictable times.
- * The only way to block such calls is to do an autoresume (preventing
- * autosuspends) while holding @udev's device lock (preventing outside
- * suspends).
- *
- * The caller must hold @udev->pm_mutex.
+ * Autosuspend requests originating from a child device or an interface
+ * driver may be made without the protection of @udev's device lock, but
+ * all other suspend calls will hold the lock.  Usbcore will insure that
+ * method calls do not arrive during bind, unbind, or reset operations.
+ * However drivers must be prepared to handle suspend calls arriving at
+ * unpredictable times.
  *
  * This routine can run only in process context.
  */
 static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
 {
         int                     status = 0;
-        int                     i = 0;
+        int                     i = 0, n = 0;
         struct usb_interface    *intf;
-        struct usb_device       *parent = udev->parent;
 
         if (udev->state == USB_STATE_NOTATTACHED ||
                         udev->state == USB_STATE_SUSPENDED)
                 goto done;
 
-        udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
-
-        if (msg.event & PM_EVENT_AUTO) {
-                status = autosuspend_check(udev, 0);
-                if (status < 0)
-                        goto done;
-        }
-
         /* Suspend all the interfaces and then udev itself */
         if (udev->actconfig) {
-                for (; i < udev->actconfig->desc.bNumInterfaces; i++) {
+                n = udev->actconfig->desc.bNumInterfaces;
+                for (i = n - 1; i >= 0; --i) {
                         intf = udev->actconfig->interface[i];
                         status = usb_suspend_interface(udev, intf, msg);
                         if (status != 0)
@@ -1199,35 +1192,21 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
 
         /* If the suspend failed, resume interfaces that did get suspended */
         if (status != 0) {
-                pm_message_t msg2;
-
-                msg2.event = msg.event ^ (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
-                while (--i >= 0) {
+                msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
+                while (++i < n) {
                         intf = udev->actconfig->interface[i];
-                        usb_resume_interface(udev, intf, msg2, 0);
+                        usb_resume_interface(udev, intf, msg, 0);
                 }
 
-                /* Try another autosuspend when the interfaces aren't busy */
-                if (msg.event & PM_EVENT_AUTO)
-                        autosuspend_check(udev, status == -EBUSY);
-
-        /* If the suspend succeeded then prevent any more URB submissions,
-         * flush any outstanding URBs, and propagate the suspend up the tree.
+        /* If the suspend succeeded then prevent any more URB submissions
+         * and flush any outstanding URBs.
          */
         } else {
-                cancel_delayed_work(&udev->autosuspend);
                 udev->can_submit = 0;
                 for (i = 0; i < 16; ++i) {
                         usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
                         usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
                 }
-
-                /* If this is just a FREEZE or a PRETHAW, udev might
-                 * not really be suspended.  Only true suspends get
-                 * propagated up the device tree.
-                 */
-                if (parent && udev->state == USB_STATE_SUSPENDED)
-                        usb_autosuspend_device(parent);
         }
 
  done:
@@ -1244,23 +1223,12 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
  * the resume method for @udev and then calls the resume methods for all
  * the interface drivers in @udev.
  *
- * Before starting the resume, the routine calls itself recursively for
- * the parent device of @udev, thereby propagating the change up the device
- * tree and assuring that @udev will be able to resume.  If the parent is
- * unable to resume successfully, the routine fails.
- *
- * The resume method calls are subject to mutual exclusion under control
- * of @udev's pm_mutex.  Many of these calls are also under the protection
- * of @udev's device lock (including all requests originating outside the
- * USB subsystem), but autoresume requests generated by a child device or
- * interface driver may not be.  Usbcore will insure that the method calls
- * do not arrive during bind, unbind, or reset operations.  However, drivers
- * must be prepared to handle resume calls arriving at unpredictable times.
- * The only way to block such calls is to do an autoresume (preventing
- * other autoresumes) while holding @udev's device lock (preventing outside
- * resumes).
- *
- * The caller must hold @udev->pm_mutex.
+ * Autoresume requests originating from a child device or an interface
+ * driver may be made without the protection of @udev's device lock, but
+ * all other resume calls will hold the lock.  Usbcore will insure that
+ * method calls do not arrive during bind, unbind, or reset operations.
+ * However drivers must be prepared to handle resume calls arriving at
+ * unpredictable times.
  *
  * This routine can run only in process context.
  */
@@ -1269,53 +1237,18 @@ static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
         int                     status = 0;
         int                     i;
         struct usb_interface    *intf;
-        struct usb_device       *parent = udev->parent;
 
-        cancel_delayed_work(&udev->autosuspend);
         if (udev->state == USB_STATE_NOTATTACHED) {
                 status = -ENODEV;
                 goto done;
         }
         udev->can_submit = 1;
 
-        /* Propagate the resume up the tree, if necessary */
-        if (udev->state == USB_STATE_SUSPENDED) {
-                if ((msg.event & PM_EVENT_AUTO) &&
-                                udev->autoresume_disabled) {
-                        status = -EPERM;
-                        goto done;
-                }
-                if (parent) {
-                        status = usb_autoresume_device(parent);
-                        if (status == 0) {
-                                status = usb_resume_device(udev, msg);
-                                if (status || udev->state ==
-                                                USB_STATE_NOTATTACHED) {
-                                        usb_autosuspend_device(parent);
-
-                                        /* It's possible usb_resume_device()
-                                         * failed after the port was
-                                         * unsuspended, causing udev to be
-                                         * logically disconnected.  We don't
-                                         * want usb_disconnect() to autosuspend
-                                         * the parent again, so tell it that
-                                         * udev disconnected while still
-                                         * suspended. */
-                                        if (udev->state ==
-                                                        USB_STATE_NOTATTACHED)
-                                                udev->discon_suspended = 1;
-                                }
-                        }
-                } else {
-
-                        /* We can't progagate beyond the USB subsystem,
-                         * so if a root hub's controller is suspended
-                         * then we're stuck. */
-                        status = usb_resume_device(udev, msg);
-                }
-        } else if (udev->reset_resume)
+        /* Resume the device */
+        if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume)
                 status = usb_resume_device(udev, msg);
 
+        /* Resume the interfaces */
         if (status == 0 && udev->actconfig) {
                 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
                         intf = udev->actconfig->interface[i];
@@ -1331,56 +1264,128 @@ static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
         return status;
 }
 
-#ifdef CONFIG_USB_SUSPEND
+static void choose_wakeup(struct usb_device *udev, pm_message_t msg)
+{
+        int                     w, i;
+        struct usb_interface    *intf;
 
-/* Internal routine to adjust a device's usage counter and change
- * its autosuspend state.
- */
-static int usb_autopm_do_device(struct usb_device *udev, int inc_usage_cnt)
+        /* Remote wakeup is needed only when we actually go to sleep.
+         * For things like FREEZE and QUIESCE, if the device is already
+         * autosuspended then its current wakeup setting is okay.
+         */
+        if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) {
+                if (udev->state != USB_STATE_SUSPENDED)
+                        udev->do_remote_wakeup = 0;
+                return;
+        }
+
+        /* If remote wakeup is permitted, see whether any interface drivers
+         * actually want it.
+         */
+        w = 0;
+        if (device_may_wakeup(&udev->dev) && udev->actconfig) {
+                for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
+                        intf = udev->actconfig->interface[i];
+                        w |= intf->needs_remote_wakeup;
+                }
+        }
+
+        /* If the device is autosuspended with the wrong wakeup setting,
+         * autoresume now so the setting can be changed.
+         */
+        if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup)
+                pm_runtime_resume(&udev->dev);
+        udev->do_remote_wakeup = w;
+}
+
+/* The device lock is held by the PM core */
+int usb_suspend(struct device *dev, pm_message_t msg)
 {
-        int     status = 0;
+        struct usb_device       *udev = to_usb_device(dev);
 
-        usb_pm_lock(udev);
-        udev->auto_pm = 1;
-        udev->pm_usage_cnt += inc_usage_cnt;
-        WARN_ON(udev->pm_usage_cnt < 0);
-        if (inc_usage_cnt)
-                udev->last_busy = jiffies;
-        if (inc_usage_cnt >= 0 && udev->pm_usage_cnt > 0) {
-                if (udev->state == USB_STATE_SUSPENDED)
-                        status = usb_resume_both(udev, PMSG_AUTO_RESUME);
-                if (status != 0)
-                        udev->pm_usage_cnt -= inc_usage_cnt;
-                else if (inc_usage_cnt)
+        do_unbind_rebind(udev, DO_UNBIND);
+        choose_wakeup(udev, msg);
+        return usb_suspend_both(udev, msg);
+}
+
+/* The device lock is held by the PM core */
+int usb_resume(struct device *dev, pm_message_t msg)
+{
+        struct usb_device       *udev = to_usb_device(dev);
+        int                     status;
+
+        /* For PM complete calls, all we do is rebind interfaces */
+        if (msg.event == PM_EVENT_ON) {
+                if (udev->state != USB_STATE_NOTATTACHED)
+                        do_unbind_rebind(udev, DO_REBIND);
+                status = 0;
+
+        /* For all other calls, take the device back to full power and
+         * tell the PM core in case it was autosuspended previously.
+         */
+        } else {
+                status = usb_resume_both(udev, msg);
+                if (status == 0) {
+                        pm_runtime_disable(dev);
+                        pm_runtime_set_active(dev);
+                        pm_runtime_enable(dev);
                         udev->last_busy = jiffies;
-        } else if (inc_usage_cnt <= 0 && udev->pm_usage_cnt <= 0) {
-                status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
+                }
         }
-        usb_pm_unlock(udev);
+
+        /* Avoid PM error messages for devices disconnected while suspended
+         * as we'll display regular disconnect messages just a bit later.
+         */
+        if (status == -ENODEV)
+                status = 0;
         return status;
 }
 
-/* usb_autosuspend_work - callback routine to autosuspend a USB device */
-void usb_autosuspend_work(struct work_struct *work)
-{
-        struct usb_device *udev =
-                container_of(work, struct usb_device, autosuspend.work);
+#endif /* CONFIG_PM */
 
-        usb_autopm_do_device(udev, 0);
+#ifdef CONFIG_USB_SUSPEND
+
+/**
+ * usb_enable_autosuspend - allow a USB device to be autosuspended
+ * @udev: the USB device which may be autosuspended
+ *
+ * This routine allows @udev to be autosuspended.  An autosuspend won't
+ * take place until the autosuspend_delay has elapsed and all the other
+ * necessary conditions are satisfied.
+ *
+ * The caller must hold @udev's device lock.
+ */
+int usb_enable_autosuspend(struct usb_device *udev)
+{
+        if (udev->autosuspend_disabled) {
+                udev->autosuspend_disabled = 0;
+                usb_autosuspend_device(udev);
+        }
+        return 0;
 }
+EXPORT_SYMBOL_GPL(usb_enable_autosuspend);
 
-/* usb_autoresume_work - callback routine to autoresume a USB device */
-void usb_autoresume_work(struct work_struct *work)
+/**
+ * usb_disable_autosuspend - prevent a USB device from being autosuspended
+ * @udev: the USB device which may not be autosuspended
+ *
+ * This routine prevents @udev from being autosuspended and wakes it up
+ * if it is already autosuspended.
+ *
+ * The caller must hold @udev's device lock.
+ */
+int usb_disable_autosuspend(struct usb_device *udev)
 {
-        struct usb_device *udev =
-                container_of(work, struct usb_device, autoresume);
+        int rc = 0;
 
-        /* Wake it up, let the drivers do their thing, and then put it
-         * back to sleep.
-         */
-        if (usb_autopm_do_device(udev, 1) == 0)
-                usb_autopm_do_device(udev, -1);
+        if (!udev->autosuspend_disabled) {
+                rc = usb_autoresume_device(udev);
+                if (rc == 0)
+                        udev->autosuspend_disabled = 1;
+        }
+        return rc;
 }
+EXPORT_SYMBOL_GPL(usb_disable_autosuspend);
 
 /**
  * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
@@ -1390,15 +1395,11 @@ void usb_autoresume_work(struct work_struct *work)
  * @udev and wants to allow it to autosuspend.  Examples would be when
  * @udev's device file in usbfs is closed or after a configuration change.
  *
- * @udev's usage counter is decremented.  If it or any of the usage counters
- * for an active interface is greater than 0, no autosuspend request will be
- * queued.  (If an interface driver does not support autosuspend then its
- * usage counter is permanently positive.)  Furthermore, if an interface
- * driver requires remote-wakeup capability during autosuspend but remote
- * wakeup is disabled, the autosuspend will fail.
+ * @udev's usage counter is decremented; if it drops to 0 and all the
+ * interfaces are inactive then a delayed autosuspend will be attempted.
+ * The attempt may fail (see autosuspend_check()).
  *
- * Often the caller will hold @udev's device lock, but this is not
- * necessary.
+ * The caller must hold @udev's device lock.
  *
  * This routine can run only in process context.
  */
@@ -1406,9 +1407,11 @@ void usb_autosuspend_device(struct usb_device *udev)
 {
         int     status;
 
-        status = usb_autopm_do_device(udev, -1);
-        dev_vdbg(&udev->dev, "%s: cnt %d\n",
-                        __func__, udev->pm_usage_cnt);
+        udev->last_busy = jiffies;
+        status = pm_runtime_put_sync(&udev->dev);
+        dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
+                        __func__, atomic_read(&udev->dev.power.usage_count),
+                        status);
 }
 
 /**
@@ -1418,17 +1421,22 @@ void usb_autosuspend_device(struct usb_device *udev)
  * This routine should be called when a core subsystem thinks @udev may
  * be ready to autosuspend.
  *
- * @udev's usage counter left unchanged.  If it or any of the usage counters
- * for an active interface is greater than 0, or autosuspend is not allowed
- * for any other reason, no autosuspend request will be queued.
+ * @udev's usage counter left unchanged.  If it is 0 and all the interfaces
+ * are inactive then an autosuspend will be attempted.  The attempt may
+ * fail or be delayed.
+ *
+ * The caller must hold @udev's device lock.
  *
  * This routine can run only in process context.
  */
 void usb_try_autosuspend_device(struct usb_device *udev)
 {
-        usb_autopm_do_device(udev, 0);
-        dev_vdbg(&udev->dev, "%s: cnt %d\n",
-                        __func__, udev->pm_usage_cnt);
+        int     status;
+
+        status = pm_runtime_idle(&udev->dev);
+        dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
+                        __func__, atomic_read(&udev->dev.power.usage_count),
+                        status);
 }
 
 /**
@@ -1437,16 +1445,15 @@ void usb_try_autosuspend_device(struct usb_device *udev)
  *
  * This routine should be called when a core subsystem wants to use @udev
  * and needs to guarantee that it is not suspended.  No autosuspend will
- * occur until usb_autosuspend_device is called.  (Note that this will not
- * prevent suspend events originating in the PM core.)  Examples would be
- * when @udev's device file in usbfs is opened or when a remote-wakeup
+ * occur until usb_autosuspend_device() is called.  (Note that this will
+ * not prevent suspend events originating in the PM core.)  Examples would
+ * be when @udev's device file in usbfs is opened or when a remote-wakeup
  * request is received.
  *
  * @udev's usage counter is incremented to prevent subsequent autosuspends.
  * However if the autoresume fails then the usage counter is re-decremented.
  *
- * Often the caller will hold @udev's device lock, but this is not
- * necessary (and attempting it might cause deadlock).
+ * The caller must hold @udev's device lock.
  *
  * This routine can run only in process context.
  */
@@ -1454,43 +1461,14 @@ int usb_autoresume_device(struct usb_device *udev)
 {
         int     status;
 
-        status = usb_autopm_do_device(udev, 1);
-        dev_vdbg(&udev->dev, "%s: status %d cnt %d\n",
-                        __func__, status, udev->pm_usage_cnt);
-        return status;
-}
-
-/* Internal routine to adjust an interface's usage counter and change
- * its device's autosuspend state.
- */
-static int usb_autopm_do_interface(struct usb_interface *intf,
-                int inc_usage_cnt)
-{
-        struct usb_device       *udev = interface_to_usbdev(intf);
-        int                     status = 0;
-
-        usb_pm_lock(udev);
-        if (intf->condition == USB_INTERFACE_UNBOUND)
-                status = -ENODEV;
-        else {
-                udev->auto_pm = 1;
-                atomic_add(inc_usage_cnt, &intf->pm_usage_cnt);
-                udev->last_busy = jiffies;
-                if (inc_usage_cnt >= 0 &&
-                                atomic_read(&intf->pm_usage_cnt) > 0) {
-                        if (udev->state == USB_STATE_SUSPENDED)
-                                status = usb_resume_both(udev,
-                                                PMSG_AUTO_RESUME);
-                        if (status != 0)
-                                atomic_sub(inc_usage_cnt, &intf->pm_usage_cnt);
-                        else
-                                udev->last_busy = jiffies;
-                } else if (inc_usage_cnt <= 0 &&
-                                atomic_read(&intf->pm_usage_cnt) <= 0) {
-                        status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
-                }
-        }
-        usb_pm_unlock(udev);
+        status = pm_runtime_get_sync(&udev->dev);
+        if (status < 0)
+                pm_runtime_put_sync(&udev->dev);
+        dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
+                        __func__, atomic_read(&udev->dev.power.usage_count),
+                        status);
+        if (status > 0)
+                status = 0;
         return status;
 }
 
@@ -1504,34 +1482,25 @@ static int usb_autopm_do_interface(struct usb_interface *intf,
  * closed.
  *
  * The routine decrements @intf's usage counter.  When the counter reaches
- * 0, a delayed autosuspend request for @intf's device is queued.  When
- * the delay expires, if @intf->pm_usage_cnt is still <= 0 along with all
- * the other usage counters for the sibling interfaces and @intf's
- * usb_device, the device and all its interfaces will be autosuspended.
- *
- * Note that @intf->pm_usage_cnt is owned by the interface driver.  The
- * core will not change its value other than the increment and decrement
- * in usb_autopm_get_interface and usb_autopm_put_interface.  The driver
- * may use this simple counter-oriented discipline or may set the value
- * any way it likes.
+ * 0, a delayed autosuspend request for @intf's device is attempted.  The
+ * attempt may fail (see autosuspend_check()).
  *
  * If the driver has set @intf->needs_remote_wakeup then autosuspend will
  * take place only if the device's remote-wakeup facility is enabled.
  *
- * Suspend method calls queued by this routine can arrive at any time
- * while @intf is resumed and its usage counter is equal to 0.  They are
- * not protected by the usb_device's lock but only by its pm_mutex.
- * Drivers must provide their own synchronization.
- *
  * This routine can run only in process context.
  */
 void usb_autopm_put_interface(struct usb_interface *intf)
 {
-        int     status;
+        struct usb_device       *udev = interface_to_usbdev(intf);
+        int                     status;
 
-        status = usb_autopm_do_interface(intf, -1);
-        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, atomic_read(&intf->pm_usage_cnt));
+        udev->last_busy = jiffies;
+        atomic_dec(&intf->pm_usage_cnt);
+        status = pm_runtime_put_sync(&intf->dev);
+        dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
+                        __func__, atomic_read(&intf->dev.power.usage_count),
+                        status);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 
@@ -1539,11 +1508,11 @@ EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
  * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be decremented
  *
- * This routine does essentially the same thing as
- * usb_autopm_put_interface(): it decrements @intf's usage counter and
- * queues a delayed autosuspend request if the counter is <= 0.  The
- * difference is that it does not acquire the device's pm_mutex;
- * callers must handle all synchronization issues themselves.
+ * This routine does much the same thing as usb_autopm_put_interface():
+ * It decrements @intf's usage counter and schedules a delayed
+ * autosuspend request if the counter is <= 0.  The difference is that it
+ * does not perform any synchronization; callers should hold a private
+ * lock and handle all synchronization issues themselves.
  *
  * Typically a driver would call this routine during an URB's completion
  * handler, if no more URBs were pending.
@@ -1553,28 +1522,58 @@ EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 void usb_autopm_put_interface_async(struct usb_interface *intf)
 {
         struct usb_device       *udev = interface_to_usbdev(intf);
+        unsigned long           last_busy;
         int                     status = 0;
 
-        if (intf->condition == USB_INTERFACE_UNBOUND) {
-                status = -ENODEV;
-        } else {
-                udev->last_busy = jiffies;
-                atomic_dec(&intf->pm_usage_cnt);
-                if (udev->autosuspend_disabled || udev->autosuspend_delay < 0)
-                        status = -EPERM;
-                else if (atomic_read(&intf->pm_usage_cnt) <= 0 &&
-                                !timer_pending(&udev->autosuspend.timer)) {
-                        queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
+        last_busy = udev->last_busy;
+        udev->last_busy = jiffies;
+        atomic_dec(&intf->pm_usage_cnt);
+        pm_runtime_put_noidle(&intf->dev);
+
+        if (!udev->autosuspend_disabled) {
+                /* Optimization: Don't schedule a delayed autosuspend if
+                 * the timer is already running and the expiration time
+                 * wouldn't change.
+                 *
+                 * We have to use the interface's timer.  Attempts to
+                 * schedule a suspend for the device would fail because
+                 * the interface is still active.
+                 */
+                if (intf->dev.power.timer_expires == 0 ||
+                                round_jiffies_up(last_busy) !=
+                                round_jiffies_up(jiffies)) {
+                        status = pm_schedule_suspend(&intf->dev,
+                                        jiffies_to_msecs(
                                         round_jiffies_up_relative(
-                                                udev->autosuspend_delay));
+                                                udev->autosuspend_delay)));
                 }
         }
-        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, atomic_read(&intf->pm_usage_cnt));
+        dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
+                        __func__, atomic_read(&intf->dev.power.usage_count),
+                        status);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
 
 /**
+ * usb_autopm_put_interface_no_suspend - decrement a USB interface's PM-usage counter
+ * @intf: the usb_interface whose counter should be decremented
+ *
+ * This routine decrements @intf's usage counter but does not carry out an
+ * autosuspend.
+ *
+ * This routine can run in atomic context.
+ */
+void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
+{
+        struct usb_device       *udev = interface_to_usbdev(intf);
+
+        udev->last_busy = jiffies;
+        atomic_dec(&intf->pm_usage_cnt);
+        pm_runtime_put_noidle(&intf->dev);
+}
+EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend);
+
+/**
  * usb_autopm_get_interface - increment a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be incremented
  *
@@ -1586,25 +1585,8 @@ EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
  * or @intf is unbound.  A typical example would be a character-device
  * driver when its device file is opened.
  *
- *
- * The routine increments @intf's usage counter.  (However if the
- * autoresume fails then the counter is re-decremented.)  So long as the
- * counter is greater than 0, autosuspend will not be allowed for @intf
- * or its usb_device.  When the driver is finished using @intf it should
- * call usb_autopm_put_interface() to decrement the usage counter and
- * queue a delayed autosuspend request (if the counter is <= 0).
- *
- *
- * Note that @intf->pm_usage_cnt is owned by the interface driver.  The
- * core will not change its value other than the increment and decrement
- * in usb_autopm_get_interface and usb_autopm_put_interface.  The driver
- * may use this simple counter-oriented discipline or may set the value
- * any way it likes.
- *
- * Resume method calls generated by this routine can arrive at any time
- * while @intf is suspended.  They are not protected by the usb_device's
- * lock but only by its pm_mutex.  Drivers must provide their own
- * synchronization.
+ * @intf's usage counter is incremented to prevent subsequent autosuspends.
+ * However if the autoresume fails then the counter is re-decremented.
  *
  * This routine can run only in process context.
  */
@@ -1612,9 +1594,16 @@ int usb_autopm_get_interface(struct usb_interface *intf)
 {
         int     status;
 
-        status = usb_autopm_do_interface(intf, 1);
-        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, atomic_read(&intf->pm_usage_cnt));
+        status = pm_runtime_get_sync(&intf->dev);
+        if (status < 0)
+                pm_runtime_put_sync(&intf->dev);
+        else
+                atomic_inc(&intf->pm_usage_cnt);
+        dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
+                        __func__, atomic_read(&intf->dev.power.usage_count),
+                        status);
+        if (status > 0)
+                status = 0;
         return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
@@ -1624,175 +1613,207 @@ EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
  * @intf: the usb_interface whose counter should be incremented
  *
  * This routine does much the same thing as
- * usb_autopm_get_interface(): it increments @intf's usage counter and
- * queues an autoresume request if the result is > 0.  The differences
- * are that it does not acquire the device's pm_mutex (callers must
- * handle all synchronization issues themselves), and it does not
- * autoresume the device directly (it only queues a request).  After a
- * successful call, the device will generally not yet be resumed.
+ * usb_autopm_get_interface(): It increments @intf's usage counter and
+ * queues an autoresume request if the device is suspended.  The
+ * differences are that it does not perform any synchronization (callers
+ * should hold a private lock and handle all synchronization issues
+ * themselves), and it does not autoresume the device directly (it only
+ * queues a request).  After a successful call, the device may not yet be
+ * resumed.
  *
  * This routine can run in atomic context.
  */
 int usb_autopm_get_interface_async(struct usb_interface *intf)
 {
-        struct usb_device       *udev = interface_to_usbdev(intf);
-        int                     status = 0;
+        int             status = 0;
+        enum rpm_status s;
 
-        if (intf->condition == USB_INTERFACE_UNBOUND)
-                status = -ENODEV;
-        else if (udev->autoresume_disabled)
-                status = -EPERM;
-        else {
+        /* Don't request a resume unless the interface is already suspending
+         * or suspended.  Doing so would force a running suspend timer to be
+         * cancelled.
+         */
+        pm_runtime_get_noresume(&intf->dev);
+        s = ACCESS_ONCE(intf->dev.power.runtime_status);
+        if (s == RPM_SUSPENDING || s == RPM_SUSPENDED)
+                status = pm_request_resume(&intf->dev);
+
+        if (status < 0 && status != -EINPROGRESS)
+                pm_runtime_put_noidle(&intf->dev);
+        else
                 atomic_inc(&intf->pm_usage_cnt);
-                if (atomic_read(&intf->pm_usage_cnt) > 0 &&
-                                udev->state == USB_STATE_SUSPENDED)
-                        queue_work(ksuspend_usb_wq, &udev->autoresume);
-        }
-        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, atomic_read(&intf->pm_usage_cnt));
+        dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
+                        __func__, atomic_read(&intf->dev.power.usage_count),
+                        status);
+        if (status > 0)
+                status = 0;
         return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
 
 /**
- * usb_autopm_set_interface - set a USB interface's autosuspend state
- * @intf: the usb_interface whose state should be set
- *
- * This routine sets the autosuspend state of @intf's device according
- * to @intf's usage counter, which the caller must have set previously.
- * If the counter is <= 0, the device is autosuspended (if it isn't
- * already suspended and if nothing else prevents the autosuspend).  If
- * the counter is > 0, the device is autoresumed (if it isn't already
- * awake).
+ * usb_autopm_get_interface_no_resume - increment a USB interface's PM-usage counter
+ * @intf: the usb_interface whose counter should be incremented
+ *
+ * This routine increments @intf's usage counter but does not carry out an
+ * autoresume.
+ *
+ * This routine can run in atomic context.
  */
-int usb_autopm_set_interface(struct usb_interface *intf)
+void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
 {
-        int     status;
+        struct usb_device       *udev = interface_to_usbdev(intf);
 
-        status = usb_autopm_do_interface(intf, 0);
-        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                        __func__, status, atomic_read(&intf->pm_usage_cnt));
-        return status;
+        udev->last_busy = jiffies;
+        atomic_inc(&intf->pm_usage_cnt);
+        pm_runtime_get_noresume(&intf->dev);
 }
-EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
+EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume);
 
-#else
+/* Internal routine to check whether we may autosuspend a device. */
+static int autosuspend_check(struct usb_device *udev)
+{
+        int                     i;
+        struct usb_interface    *intf;
+        unsigned long           suspend_time, j;
 
-void usb_autosuspend_work(struct work_struct *work)
-{}
+        /* Fail if autosuspend is disabled, or any interfaces are in use, or
+         * any interface drivers require remote wakeup but it isn't available.
+         */
+        udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
+        if (udev->actconfig) {
+                for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
+                        intf = udev->actconfig->interface[i];
 
-void usb_autoresume_work(struct work_struct *work)
-{}
+                        /* We don't need to check interfaces that are
+                         * disabled for runtime PM.  Either they are unbound
+                         * or else their drivers don't support autosuspend
+                         * and so they are permanently active.
+                         */
+                        if (intf->dev.power.disable_depth)
+                                continue;
+                        if (atomic_read(&intf->dev.power.usage_count) > 0)
+                                return -EBUSY;
+                        if (intf->needs_remote_wakeup &&
+                                        !udev->do_remote_wakeup) {
+                                dev_dbg(&udev->dev, "remote wakeup needed "
+                                                "for autosuspend\n");
+                                return -EOPNOTSUPP;
+                        }
 
-#endif /* CONFIG_USB_SUSPEND */
+                        /* Don't allow autosuspend if the device will need
+                         * a reset-resume and any of its interface drivers
+                         * doesn't include support or needs remote wakeup.
+                         */
+                        if (udev->quirks & USB_QUIRK_RESET_RESUME) {
+                                struct usb_driver *driver;
 
-/**
- * usb_external_suspend_device - external suspend of a USB device and its interfaces
- * @udev: the usb_device to suspend
- * @msg: Power Management message describing this state transition
- *
- * This routine handles external suspend requests: ones not generated
- * internally by a USB driver (autosuspend) but rather coming from the user
- * (via sysfs) or the PM core (system sleep).  The suspend will be carried
- * out regardless of @udev's usage counter or those of its interfaces,
- * and regardless of whether or not remote wakeup is enabled.  Of course,
- * interface drivers still have the option of failing the suspend (if
- * there are unsuspended children, for example).
- *
- * The caller must hold @udev's device lock.
- */
-int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
-{
-        int     status;
+                                driver = to_usb_driver(intf->dev.driver);
+                                if (!driver->reset_resume ||
+                                                intf->needs_remote_wakeup)
+                                        return -EOPNOTSUPP;
+                        }
+                }
+        }
 
-        do_unbind_rebind(udev, DO_UNBIND);
-        usb_pm_lock(udev);
-        udev->auto_pm = 0;
-        status = usb_suspend_both(udev, msg);
-        usb_pm_unlock(udev);
-        return status;
+        /* If everything is okay but the device hasn't been idle for long
+         * enough, queue a delayed autosuspend request.
+         */
+        j = ACCESS_ONCE(jiffies);
+        suspend_time = udev->last_busy + udev->autosuspend_delay;
+        if (time_before(j, suspend_time)) {
+                pm_schedule_suspend(&udev->dev, jiffies_to_msecs(
+                                round_jiffies_up_relative(suspend_time - j)));
+                return -EAGAIN;
+        }
+        return 0;
 }
 
-/**
- * usb_external_resume_device - external resume of a USB device and its interfaces
- * @udev: the usb_device to resume
- * @msg: Power Management message describing this state transition
- *
- * This routine handles external resume requests: ones not generated
- * internally by a USB driver (autoresume) but rather coming from the user
- * (via sysfs), the PM core (system resume), or the device itself (remote
- * wakeup).  @udev's usage counter is unaffected.
- *
- * The caller must hold @udev's device lock.
- */
-int usb_external_resume_device(struct usb_device *udev, pm_message_t msg)
+static int usb_runtime_suspend(struct device *dev)
 {
-        int     status;
+        int     status = 0;
 
-        usb_pm_lock(udev);
-        udev->auto_pm = 0;
-        status = usb_resume_both(udev, msg);
-        udev->last_busy = jiffies;
-        usb_pm_unlock(udev);
-        if (status == 0)
-                do_unbind_rebind(udev, DO_REBIND);
+        /* A USB device can be suspended if it passes the various autosuspend
+         * checks.  Runtime suspend for a USB device means suspending all the
+         * interfaces and then the device itself.
+         */
+        if (is_usb_device(dev)) {
+                struct usb_device       *udev = to_usb_device(dev);
 
-        /* Now that the device is awake, we can start trying to autosuspend
-         * it again. */
-        if (status == 0)
-                usb_try_autosuspend_device(udev);
-        return status;
-}
+                if (autosuspend_check(udev) != 0)
+                        return -EAGAIN;
 
-int usb_suspend(struct device *dev, pm_message_t msg)
-{
-        struct usb_device       *udev;
+                status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
 
-        udev = to_usb_device(dev);
+                /* If an interface fails the suspend, adjust the last_busy
+                 * time so that we don't get another suspend attempt right
+                 * away.
+                 */
+                if (status) {
+                        udev->last_busy = jiffies +
+                                        (udev->autosuspend_delay == 0 ?
+                                                HZ/2 : 0);
+                }
 
-        /* If udev is already suspended, we can skip this suspend and
-         * we should also skip the upcoming system resume.  High-speed
-         * root hubs are an exception; they need to resume whenever the
-         * system wakes up in order for USB-PERSIST port handover to work
-         * properly.
-         */
-        if (udev->state == USB_STATE_SUSPENDED) {
-                if (udev->parent || udev->speed != USB_SPEED_HIGH)
-                        udev->skip_sys_resume = 1;
-                return 0;
+                /* Prevent the parent from suspending immediately after */
+                else if (udev->parent) {
+                        udev->parent->last_busy = jiffies;
+                }
         }
 
-        udev->skip_sys_resume = 0;
-        return usb_external_suspend_device(udev, msg);
+        /* Runtime suspend for a USB interface doesn't mean anything. */
+        return status;
 }
 
-int usb_resume(struct device *dev, pm_message_t msg)
+static int usb_runtime_resume(struct device *dev)
 {
-        struct usb_device       *udev;
-        int                     status;
+        /* Runtime resume for a USB device means resuming both the device
+         * and all its interfaces.
+         */
+        if (is_usb_device(dev)) {
+                struct usb_device       *udev = to_usb_device(dev);
+                int                     status;
+
+                status = usb_resume_both(udev, PMSG_AUTO_RESUME);
+                udev->last_busy = jiffies;
+                return status;
+        }
 
-        udev = to_usb_device(dev);
+        /* Runtime resume for a USB interface doesn't mean anything. */
+        return 0;
+}
 
-        /* If udev->skip_sys_resume is set then udev was already suspended
-         * when the system sleep started, so we don't want to resume it
-         * during this system wakeup.
+static int usb_runtime_idle(struct device *dev)
+{
+        /* An idle USB device can be suspended if it passes the various
+         * autosuspend checks.  An idle interface can be suspended at
+         * any time.
          */
-        if (udev->skip_sys_resume)
-                return 0;
-        status = usb_external_resume_device(udev, msg);
+        if (is_usb_device(dev)) {
+                struct usb_device       *udev = to_usb_device(dev);
 
-        /* Avoid PM error messages for devices disconnected while suspended
-         * as we'll display regular disconnect messages just a bit later.
-         */
-        if (status == -ENODEV)
-                return 0;
-        return status;
+                if (autosuspend_check(udev) != 0)
+                        return 0;
+        }
+
+        pm_runtime_suspend(dev);
+        return 0;
 }
 
-#endif /* CONFIG_PM */
+static struct dev_pm_ops usb_bus_pm_ops = {
+        .runtime_suspend =      usb_runtime_suspend,
+        .runtime_resume =       usb_runtime_resume,
+        .runtime_idle =         usb_runtime_idle,
+};
+
+#else
+
+#define usb_bus_pm_ops  (*(struct dev_pm_ops *) NULL)
+
+#endif /* CONFIG_USB_SUSPEND */
 
 struct bus_type usb_bus_type = {
         .name =         "usb",
         .match =        usb_device_match,
         .uevent =       usb_uevent,
+        .pm =           &usb_bus_pm_ops,
 };
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index fdfaa7885515..4f84a41ee7a8 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -11,6 +11,7 @@
 
 #include <linux/kernel.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <linux/idr.h>
 #include <linux/usb.h>
 #include "usb.h"
@@ -186,6 +187,7 @@ int usb_create_ep_devs(struct device *parent,
         ep_dev->dev.parent = parent;
         ep_dev->dev.release = ep_device_release;
         dev_set_name(&ep_dev->dev, "ep_%02x", endpoint->desc.bEndpointAddress);
+        device_enable_async_suspend(&ep_dev->dev);
 
         retval = device_register(&ep_dev->dev);
         if (retval)
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index 222ee07ea680..f06f5dbc8cdc 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/rwsem.h>
+#include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include <linux/usb.h>
 
@@ -34,7 +35,6 @@ static int usb_open(struct inode * inode, struct file * file)
         int err = -ENODEV;
         const struct file_operations *old_fops, *new_fops = NULL;
 
-        lock_kernel();
         down_read(&minor_rwsem);
         c = usb_minors[minor];
 
@@ -53,7 +53,6 @@ static int usb_open(struct inode * inode, struct file * file)
         fops_put(old_fops);
  done:
         up_read(&minor_rwsem);
-        unlock_kernel();
         return err;
 }
 
@@ -99,6 +98,7 @@ static int init_usb_class(void)
                 printk(KERN_ERR "class_create failed for usb devices\n");
                 kfree(usb_class);
                 usb_class = NULL;
+                goto exit;
         }
         usb_class->class->devnode = usb_devnode;
 
diff --git a/drivers/usb/core/generic.c b/drivers/usb/core/generic.c
index 05e6d313961e..2c95153c0f24 100644
--- a/drivers/usb/core/generic.c
+++ b/drivers/usb/core/generic.c
@@ -120,7 +120,7 @@ int usb_choose_configuration(struct usb_device *udev)
                  * than a vendor-specific driver. */
                 else if (udev->descriptor.bDeviceClass !=
                                                 USB_CLASS_VENDOR_SPEC &&
-                                (!desc || desc->bInterfaceClass !=
+                                (desc && desc->bInterfaceClass !=
                                                 USB_CLASS_VENDOR_SPEC)) {
                         best = c;
                         break;
@@ -139,7 +139,7 @@ int usb_choose_configuration(struct usb_device *udev)
 
         if (best) {
                 i = best->desc.bConfigurationValue;
-                dev_info(&udev->dev,
+                dev_dbg(&udev->dev,
                         "configuration #%d chosen from %d choice%s\n",
                         i, num_configs, plural(num_configs));
         } else {
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index 91f2885b6ee1..15286533c15a 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -19,6 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/pci.h>
+#include <linux/pm_runtime.h>
 #include <linux/usb.h>
 
 #include <asm/io.h>
@@ -37,6 +38,122 @@
 
 /* PCI-based HCs are common, but plenty of non-PCI HCs are used too */
 
+#ifdef CONFIG_PM_SLEEP
+
+/* Coordinate handoffs between EHCI and companion controllers
+ * during system resume
+ */
+
+static DEFINE_MUTEX(companions_mutex);
+
+#define CL_UHCI         PCI_CLASS_SERIAL_USB_UHCI
+#define CL_OHCI         PCI_CLASS_SERIAL_USB_OHCI
+#define CL_EHCI         PCI_CLASS_SERIAL_USB_EHCI
+
+enum companion_action {
+        SET_HS_COMPANION, CLEAR_HS_COMPANION, WAIT_FOR_COMPANIONS
+};
+
+static void companion_common(struct pci_dev *pdev, struct usb_hcd *hcd,
+                enum companion_action action)
+{
+        struct pci_dev          *companion;
+        struct usb_hcd          *companion_hcd;
+        unsigned int            slot = PCI_SLOT(pdev->devfn);
+
+        /* Iterate through other PCI functions in the same slot.
+         * If pdev is OHCI or UHCI then we are looking for EHCI, and
+         * vice versa.
+         */
+        companion = NULL;
+        for (;;) {
+                companion = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, companion);
+                if (!companion)
+                        break;
+                if (companion->bus != pdev->bus ||
+                                PCI_SLOT(companion->devfn) != slot)
+                        continue;
+
+                companion_hcd = pci_get_drvdata(companion);
+                if (!companion_hcd)
+                        continue;
+
+                /* For SET_HS_COMPANION, store a pointer to the EHCI bus in
+                 * the OHCI/UHCI companion bus structure.
+                 * For CLEAR_HS_COMPANION, clear the pointer to the EHCI bus
+                 * in the OHCI/UHCI companion bus structure.
+                 * For WAIT_FOR_COMPANIONS, wait until the OHCI/UHCI
+                 * companion controllers have fully resumed.
+                 */
+
+                if ((pdev->class == CL_OHCI || pdev->class == CL_UHCI) &&
+                                companion->class == CL_EHCI) {
+                        /* action must be SET_HS_COMPANION */
+                        dev_dbg(&companion->dev, "HS companion for %s\n",
+                                        dev_name(&pdev->dev));
+                        hcd->self.hs_companion = &companion_hcd->self;
+
+                } else if (pdev->class == CL_EHCI &&
+                                (companion->class == CL_OHCI ||
+                                companion->class == CL_UHCI)) {
+                        switch (action) {
+                        case SET_HS_COMPANION:
+                                dev_dbg(&pdev->dev, "HS companion for %s\n",
+                                                dev_name(&companion->dev));
+                                companion_hcd->self.hs_companion = &hcd->self;
+                                break;
+                        case CLEAR_HS_COMPANION:
+                                companion_hcd->self.hs_companion = NULL;
+                                break;
+                        case WAIT_FOR_COMPANIONS:
+                                device_pm_wait_for_dev(&pdev->dev,
+                                                &companion->dev);
+                                break;
+                        }
+                }
+        }
+}
+
+static void set_hs_companion(struct pci_dev *pdev, struct usb_hcd *hcd)
+{
+        mutex_lock(&companions_mutex);
+        dev_set_drvdata(&pdev->dev, hcd);
+        companion_common(pdev, hcd, SET_HS_COMPANION);
+        mutex_unlock(&companions_mutex);
+}
+
+static void clear_hs_companion(struct pci_dev *pdev, struct usb_hcd *hcd)
+{
+        mutex_lock(&companions_mutex);
+        dev_set_drvdata(&pdev->dev, NULL);
+
+        /* If pdev is OHCI or UHCI, just clear its hs_companion pointer */
+        if (pdev->class == CL_OHCI || pdev->class == CL_UHCI)
+                hcd->self.hs_companion = NULL;
+
+        /* Otherwise search for companion buses and clear their pointers */
+        else
+                companion_common(pdev, hcd, CLEAR_HS_COMPANION);
+        mutex_unlock(&companions_mutex);
+}
+
+static void wait_for_companions(struct pci_dev *pdev, struct usb_hcd *hcd)
+{
+        /* Only EHCI controllers need to wait.
+         * No locking is needed because a controller cannot be resumed
+         * while one of its companions is getting unbound.
+         */
+        if (pdev->class == CL_EHCI)
+                companion_common(pdev, hcd, WAIT_FOR_COMPANIONS);
+}
+
+#else /* !CONFIG_PM_SLEEP */
+
+static inline void set_hs_companion(struct pci_dev *d, struct usb_hcd *h) {}
+static inline void clear_hs_companion(struct pci_dev *d, struct usb_hcd *h) {}
+static inline void wait_for_companions(struct pci_dev *d, struct usb_hcd *h) {}
+
+#endif /* !CONFIG_PM_SLEEP */
 
 /*-------------------------------------------------------------------------*/
 
@@ -123,7 +240,7 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 if (region == PCI_ROM_RESOURCE) {
                         dev_dbg(&dev->dev, "no i/o regions available\n");
                         retval = -EBUSY;
-                        goto err1;
+                        goto err2;
                 }
         }
 
@@ -132,6 +249,7 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         retval = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED);
         if (retval != 0)
                 goto err4;
+        set_hs_companion(dev, hcd);
         return retval;
 
  err4:
@@ -142,6 +260,7 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         } else
                 release_region(hcd->rsrc_start, hcd->rsrc_len);
  err2:
+        clear_hs_companion(dev, hcd);
         usb_put_hcd(hcd);
  err1:
         pci_disable_device(dev);
@@ -180,6 +299,7 @@ void usb_hcd_pci_remove(struct pci_dev *dev)
         } else {
                 release_region(hcd->rsrc_start, hcd->rsrc_len);
         }
+        clear_hs_companion(dev, hcd);
         usb_put_hcd(hcd);
         pci_disable_device(dev);
 }
@@ -344,6 +464,11 @@ static int resume_common(struct device *dev, bool hibernated)
         clear_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
 
         if (hcd->driver->pci_resume) {
+                /* This call should be made only during system resume,
+                 * not during runtime resume.
+                 */
+                wait_for_companions(pci_dev, hcd);
+
                 retval = hcd->driver->pci_resume(hcd, hibernated);
                 if (retval) {
                         dev_err(dev, "PCI post-resume error %d!\n", retval);
@@ -363,7 +488,7 @@ static int hcd_pci_restore(struct device *dev)
         return resume_common(dev, true);
 }
 
-struct dev_pm_ops usb_hcd_pci_pm_ops = {
+const struct dev_pm_ops usb_hcd_pci_pm_ops = {
         .suspend        = hcd_pci_suspend,
         .suspend_noirq  = hcd_pci_suspend_noirq,
         .resume_noirq   = hcd_pci_resume_noirq,
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 34de475f016e..2f8cedda8007 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -38,6 +38,8 @@
 #include <asm/unaligned.h>
 #include <linux/platform_device.h>
 #include <linux/workqueue.h>
+#include <linux/mutex.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/usb.h>
 
@@ -140,7 +142,7 @@ static const u8 usb3_rh_dev_descriptor[18] = {
         0x09,       /*  __u8  bMaxPacketSize0; 2^9 = 512 Bytes */
 
         0x6b, 0x1d, /*  __le16 idVendor; Linux Foundation */
-        0x02, 0x00, /*  __le16 idProduct; device 0x0002 */
+        0x03, 0x00, /*  __le16 idProduct; device 0x0003 */
         KERNEL_VER, KERNEL_REL, /*  __le16 bcdDevice */
 
         0x03,       /*  __u8  iManufacturer; */
@@ -1275,13 +1277,16 @@ static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
 
         if (usb_endpoint_xfer_control(&urb->ep->desc)
             && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) {
-                if (hcd->self.uses_dma)
+                if (hcd->self.uses_dma) {
                         urb->setup_dma = dma_map_single(
                                         hcd->self.controller,
                                         urb->setup_packet,
                                         sizeof(struct usb_ctrlrequest),
                                         DMA_TO_DEVICE);
-                else if (hcd->driver->flags & HCD_LOCAL_MEM)
+                        if (dma_mapping_error(hcd->self.controller,
+                                                urb->setup_dma))
+                                return -EAGAIN;
+                } else if (hcd->driver->flags & HCD_LOCAL_MEM)
                         ret = hcd_alloc_coherent(
                                         urb->dev->bus, mem_flags,
                                         &urb->setup_dma,
@@ -1293,13 +1298,16 @@ static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
         dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
         if (ret == 0 && urb->transfer_buffer_length != 0
             && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
-                if (hcd->self.uses_dma)
+                if (hcd->self.uses_dma) {
                         urb->transfer_dma = dma_map_single (
                                         hcd->self.controller,
                                         urb->transfer_buffer,
                                         urb->transfer_buffer_length,
                                         dir);
-                else if (hcd->driver->flags & HCD_LOCAL_MEM) {
+                        if (dma_mapping_error(hcd->self.controller,
+                                                urb->transfer_dma))
+                                return -EAGAIN;
+                } else if (hcd->driver->flags & HCD_LOCAL_MEM) {
                         ret = hcd_alloc_coherent(
                                         urb->dev->bus, mem_flags,
                                         &urb->transfer_dma,
@@ -1589,19 +1597,34 @@ rescan:
         }
 }
 
-/* Check whether a new configuration or alt setting for an interface
- * will exceed the bandwidth for the bus (or the host controller resources).
- * Only pass in a non-NULL config or interface, not both!
- * Passing NULL for both new_config and new_intf means the device will be
- * de-configured by issuing a set configuration 0 command.
+/**
+ * usb_hcd_alloc_bandwidth - check whether a new bandwidth setting exceeds
+ *                              the bus bandwidth
+ * @udev: target &usb_device
+ * @new_config: new configuration to install
+ * @cur_alt: the current alternate interface setting
+ * @new_alt: alternate interface setting that is being installed
+ *
+ * To change configurations, pass in the new configuration in new_config,
+ * and pass NULL for cur_alt and new_alt.
+ *
+ * To reset a device's configuration (put the device in the ADDRESSED state),
+ * pass in NULL for new_config, cur_alt, and new_alt.
+ *
+ * To change alternate interface settings, pass in NULL for new_config,
+ * pass in the current alternate interface setting in cur_alt,
+ * and pass in the new alternate interface setting in new_alt.
+ *
+ * Returns an error if the requested bandwidth change exceeds the
+ * bus bandwidth or host controller internal resources.
  */
-int usb_hcd_check_bandwidth(struct usb_device *udev,
+int usb_hcd_alloc_bandwidth(struct usb_device *udev,
                 struct usb_host_config *new_config,
-                struct usb_interface *new_intf)
+                struct usb_host_interface *cur_alt,
+                struct usb_host_interface *new_alt)
 {
         int num_intfs, i, j;
-        struct usb_interface_cache *intf_cache;
-        struct usb_host_interface *alt = 0;
+        struct usb_host_interface *alt = NULL;
         int ret = 0;
         struct usb_hcd *hcd;
         struct usb_host_endpoint *ep;
@@ -1611,7 +1634,7 @@ int usb_hcd_check_bandwidth(struct usb_device *udev,
                 return 0;
 
         /* Configuration is being removed - set configuration 0 */
-        if (!new_config && !new_intf) {
+        if (!new_config && !cur_alt) {
                 for (i = 1; i < 16; ++i) {
                         ep = udev->ep_out[i];
                         if (ep)
@@ -1648,19 +1671,17 @@ int usb_hcd_check_bandwidth(struct usb_device *udev,
                         }
                 }
                 for (i = 0; i < num_intfs; ++i) {
+                        struct usb_host_interface *first_alt;
+                        int iface_num;
+
+                        first_alt = &new_config->intf_cache[i]->altsetting[0];
+                        iface_num = first_alt->desc.bInterfaceNumber;
+                        /* Set up endpoints for alternate interface setting 0 */
+                        alt = usb_find_alt_setting(new_config, iface_num, 0);
+                        if (!alt)
+                                /* No alt setting 0? Pick the first setting. */
+                                alt = first_alt;
 
-                        /* Dig the endpoints for alt setting 0 out of the
-                         * interface cache for this interface
-                         */
-                        intf_cache = new_config->intf_cache[i];
-                        for (j = 0; j < intf_cache->num_altsetting; j++) {
-                                if (intf_cache->altsetting[j].desc.bAlternateSetting == 0)
-                                        alt = &intf_cache->altsetting[j];
-                        }
-                        if (!alt) {
-                                printk(KERN_DEBUG "Did not find alt setting 0 for intf %d\n", i);
-                                continue;
-                        }
                         for (j = 0; j < alt->desc.bNumEndpoints; j++) {
                                 ret = hcd->driver->add_endpoint(hcd, udev, &alt->endpoint[j]);
                                 if (ret < 0)
@@ -1668,6 +1689,40 @@ int usb_hcd_check_bandwidth(struct usb_device *udev,
                         }
                 }
         }
+        if (cur_alt && new_alt) {
+                struct usb_interface *iface = usb_ifnum_to_if(udev,
+                                cur_alt->desc.bInterfaceNumber);
+
+                if (iface->resetting_device) {
+                        /*
+                         * The USB core just reset the device, so the xHCI host
+                         * and the device will think alt setting 0 is installed.
+                         * However, the USB core will pass in the alternate
+                         * setting installed before the reset as cur_alt.  Dig
+                         * out the alternate setting 0 structure, or the first
+                         * alternate setting if a broken device doesn't have alt
+                         * setting 0.
+                         */
+                        cur_alt = usb_altnum_to_altsetting(iface, 0);
+                        if (!cur_alt)
+                                cur_alt = &iface->altsetting[0];
+                }
+
+                /* Drop all the endpoints in the current alt setting */
+                for (i = 0; i < cur_alt->desc.bNumEndpoints; i++) {
+                        ret = hcd->driver->drop_endpoint(hcd, udev,
+                                        &cur_alt->endpoint[i]);
+                        if (ret < 0)
+                                goto reset;
+                }
+                /* Add all the endpoints in the new alt setting */
+                for (i = 0; i < new_alt->desc.bNumEndpoints; i++) {
+                        ret = hcd->driver->add_endpoint(hcd, udev,
+                                        &new_alt->endpoint[i]);
+                        if (ret < 0)
+                                goto reset;
+                }
+        }
         ret = hcd->driver->check_bandwidth(hcd, udev);
 reset:
         if (ret < 0)
@@ -1804,6 +1859,10 @@ int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg)
         return status;
 }
 
+#endif  /* CONFIG_PM */
+
+#ifdef  CONFIG_USB_SUSPEND
+
 /* Workqueue routine for root-hub remote wakeup */
 static void hcd_resume_work(struct work_struct *work)
 {
@@ -1811,8 +1870,7 @@ static void hcd_resume_work(struct work_struct *work)
         struct usb_device *udev = hcd->self.root_hub;
 
         usb_lock_device(udev);
-        usb_mark_last_busy(udev);
-        usb_external_resume_device(udev, PMSG_REMOTE_RESUME);
+        usb_remote_wakeup(udev);
         usb_unlock_device(udev);
 }
 
@@ -1831,12 +1889,12 @@ void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
 
         spin_lock_irqsave (&hcd_root_hub_lock, flags);
         if (hcd->rh_registered)
-                queue_work(ksuspend_usb_wq, &hcd->wakeup_work);
+                queue_work(pm_wq, &hcd->wakeup_work);
         spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
 }
 EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
 
-#endif
+#endif  /* CONFIG_USB_SUSPEND */
 
 /*-------------------------------------------------------------------------*/
 
@@ -1981,9 +2039,10 @@ struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
         init_timer(&hcd->rh_timer);
         hcd->rh_timer.function = rh_timer_func;
         hcd->rh_timer.data = (unsigned long) hcd;
-#ifdef CONFIG_PM
+#ifdef CONFIG_USB_SUSPEND
         INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
 #endif
+        mutex_init(&hcd->bandwidth_mutex);
 
         hcd->driver = driver;
         hcd->product_desc = (driver->product_desc) ? driver->product_desc :
@@ -2180,7 +2239,7 @@ void usb_remove_hcd(struct usb_hcd *hcd)
         hcd->rh_registered = 0;
         spin_unlock_irq (&hcd_root_hub_lock);
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_USB_SUSPEND
         cancel_work_sync(&hcd->wakeup_work);
 #endif
 
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index 79782a1c43f6..a3cdb09734ab 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -80,7 +80,7 @@ struct usb_hcd {
 
         struct timer_list       rh_timer;       /* drives root-hub polling */
         struct urb              *status_urb;    /* the current status urb */
-#ifdef CONFIG_PM
+#ifdef CONFIG_USB_SUSPEND
         struct work_struct      wakeup_work;    /* for remote wakeup */
 #endif
 
@@ -111,6 +111,20 @@ struct usb_hcd {
         u64                     rsrc_len;       /* memory/io resource length */
         unsigned                power_budget;   /* in mA, 0 = no limit */
 
+        /* bandwidth_mutex should be taken before adding or removing
+         * any new bus bandwidth constraints:
+         *   1. Before adding a configuration for a new device.
+         *   2. Before removing the configuration to put the device into
+         *      the addressed state.
+         *   3. Before selecting a different configuration.
+         *   4. Before selecting an alternate interface setting.
+         *
+         * bandwidth_mutex should be dropped after a successful control message
+         * to the device, or resetting the bandwidth after a failed attempt.
+         */
+        struct mutex            bandwidth_mutex;
+
+
 #define HCD_BUFFER_POOLS        4
         struct dma_pool         *pool [HCD_BUFFER_POOLS];
 
@@ -234,7 +248,7 @@ struct hc_driver {
         /* xHCI specific functions */
                 /* Called by usb_alloc_dev to alloc HC device structures */
         int     (*alloc_dev)(struct usb_hcd *, struct usb_device *);
-                /* Called by usb_release_dev to free HC device structures */
+                /* Called by usb_disconnect to free HC device structures */
         void    (*free_dev)(struct usb_hcd *, struct usb_device *);
 
         /* Bandwidth computation functions */
@@ -272,6 +286,7 @@ struct hc_driver {
                  */
         int     (*update_hub_device)(struct usb_hcd *, struct usb_device *hdev,
                         struct usb_tt *tt, gfp_t mem_flags);
+        int     (*reset_device)(struct usb_hcd *, struct usb_device *);
 };
 
 extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb);
@@ -290,9 +305,10 @@ extern void usb_hcd_disable_endpoint(struct usb_device *udev,
 extern void usb_hcd_reset_endpoint(struct usb_device *udev,
                 struct usb_host_endpoint *ep);
 extern void usb_hcd_synchronize_unlinks(struct usb_device *udev);
-extern int usb_hcd_check_bandwidth(struct usb_device *udev,
+extern int usb_hcd_alloc_bandwidth(struct usb_device *udev,
                 struct usb_host_config *new_config,
-                struct usb_interface *new_intf);
+                struct usb_host_interface *old_alt,
+                struct usb_host_interface *new_alt);
 extern int usb_hcd_get_frame_number(struct usb_device *udev);
 
 extern struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,
@@ -315,7 +331,7 @@ extern void usb_hcd_pci_remove(struct pci_dev *dev);
 extern void usb_hcd_pci_shutdown(struct pci_dev *dev);
 
 #ifdef CONFIG_PM_SLEEP
-extern struct dev_pm_ops        usb_hcd_pci_pm_ops;
+extern const struct dev_pm_ops usb_hcd_pci_pm_ops;
 #endif
 #endif /* CONFIG_PCI */
 
@@ -448,16 +464,20 @@ extern int usb_find_interface_driver(struct usb_device *dev,
 #define usb_endpoint_out(ep_dir)        (!((ep_dir) & USB_DIR_IN))
 
 #ifdef CONFIG_PM
-extern void usb_hcd_resume_root_hub(struct usb_hcd *hcd);
 extern void usb_root_hub_lost_power(struct usb_device *rhdev);
 extern int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg);
 extern int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg);
+#endif /* CONFIG_PM */
+
+#ifdef CONFIG_USB_SUSPEND
+extern void usb_hcd_resume_root_hub(struct usb_hcd *hcd);
 #else
 static inline void usb_hcd_resume_root_hub(struct usb_hcd *hcd)
 {
         return;
 }
-#endif /* CONFIG_PM */
+#endif /* CONFIG_USB_SUSPEND */
+
 
 /*
  * USB device fs stuff
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 0f857e645058..0940ccd6f4f4 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -22,6 +22,7 @@
 #include <linux/kthread.h>
 #include <linux/mutex.h>
 #include <linux/freezer.h>
+#include <linux/pm_runtime.h>
 
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
@@ -45,7 +46,6 @@ struct usb_hub {
 
         /* buffer for urb ... with extra space in case of babble */
         char                    (*buffer)[8];
-        dma_addr_t              buffer_dma;     /* DMA address for buffer */
         union {
                 struct usb_hub_status   hub;
                 struct usb_port_status  port;
@@ -61,6 +61,8 @@ struct usb_hub {
                                                         status change */
         unsigned long           busy_bits[1];   /* ports being reset or
                                                         resumed */
+        unsigned long           removed_bits[1]; /* ports with a "removed"
+                                                        device present */
 #if USB_MAXCHILDREN > 31 /* 8*sizeof(unsigned long) - 1 */
 #error event_bits[] is too short!
 #endif
@@ -374,12 +376,13 @@ static void kick_khubd(struct usb_hub *hub)
 {
         unsigned long   flags;
 
-        /* Suppress autosuspend until khubd runs */
-        atomic_set(&to_usb_interface(hub->intfdev)->pm_usage_cnt, 1);
-
         spin_lock_irqsave(&hub_event_lock, flags);
         if (!hub->disconnected && list_empty(&hub->event_list)) {
                 list_add_tail(&hub->event_list, &hub_event_list);
+
+                /* Suppress autosuspend until khubd runs */
+                usb_autopm_get_interface_no_resume(
+                                to_usb_interface(hub->intfdev));
                 wake_up(&khubd_wait);
         }
         spin_unlock_irqrestore(&hub_event_lock, flags);
@@ -636,8 +639,35 @@ static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
         kick_khubd(hub);
 }
 
+/**
+ * usb_remove_device - disable a device's port on its parent hub
+ * @udev: device to be disabled and removed
+ * Context: @udev locked, must be able to sleep.
+ *
+ * After @udev's port has been disabled, khubd is notified and it will
+ * see that the device has been disconnected.  When the device is
+ * physically unplugged and something is plugged in, the events will
+ * be received and processed normally.
+ */
+int usb_remove_device(struct usb_device *udev)
+{
+        struct usb_hub *hub;
+        struct usb_interface *intf;
+
+        if (!udev->parent)      /* Can't remove a root hub */
+                return -EINVAL;
+        hub = hdev_to_hub(udev->parent);
+        intf = to_usb_interface(hub->intfdev);
+
+        usb_autopm_get_interface(intf);
+        set_bit(udev->portnum, hub->removed_bits);
+        hub_port_logical_disconnect(hub, udev->portnum);
+        usb_autopm_put_interface(intf);
+        return 0;
+}
+
 enum hub_activation_type {
-        HUB_INIT, HUB_INIT2, HUB_INIT3,
+        HUB_INIT, HUB_INIT2, HUB_INIT3,         /* INITs must come first */
         HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
 };
 
@@ -682,8 +712,8 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                         msecs_to_jiffies(delay));
 
                         /* Suppress autosuspend until init is done */
-                        atomic_set(&to_usb_interface(hub->intfdev)->
-                                        pm_usage_cnt, 1);
+                        usb_autopm_get_interface_no_resume(
+                                        to_usb_interface(hub->intfdev));
                         return;         /* Continues at init2: below */
                 } else {
                         hub_power_on(hub, true);
@@ -731,6 +761,13 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                         USB_PORT_FEAT_C_ENABLE);
                 }
 
+                /* We can forget about a "removed" device when there's a
+                 * physical disconnect or the connect status changes.
+                 */
+                if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
+                                (portchange & USB_PORT_STAT_C_CONNECTION))
+                        clear_bit(port1, hub->removed_bits);
+
                 if (!udev || udev->state == USB_STATE_NOTATTACHED) {
                         /* Tell khubd to disconnect the device or
                          * check for a new connection
@@ -792,6 +829,10 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
 
         /* Scan all ports that need attention */
         kick_khubd(hub);
+
+        /* Allow autosuspend if it was suppressed */
+        if (type <= HUB_INIT3)
+                usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
 }
 
 /* Implement the continuations for the delays above */
@@ -869,8 +910,7 @@ static int hub_configure(struct usb_hub *hub,
         int maxp, ret;
         char *message = "out of memory";
 
-        hub->buffer = usb_buffer_alloc(hdev, sizeof(*hub->buffer), GFP_KERNEL,
-                        &hub->buffer_dma);
+        hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
         if (!hub->buffer) {
                 ret = -ENOMEM;
                 goto fail;
@@ -1111,8 +1151,6 @@ static int hub_configure(struct usb_hub *hub,
 
         usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
                 hub, endpoint->bInterval);
-        hub->urb->transfer_dma = hub->buffer_dma;
-        hub->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
         /* maybe cycle the hub leds */
         if (hub->has_indicators && blinkenlights)
@@ -1144,7 +1182,10 @@ static void hub_disconnect(struct usb_interface *intf)
 
         /* Take the hub off the event list and don't let it be added again */
         spin_lock_irq(&hub_event_lock);
-        list_del_init(&hub->event_list);
+        if (!list_empty(&hub->event_list)) {
+                list_del_init(&hub->event_list);
+                usb_autopm_put_interface_no_suspend(intf);
+        }
         hub->disconnected = 1;
         spin_unlock_irq(&hub_event_lock);
 
@@ -1162,8 +1203,7 @@ static void hub_disconnect(struct usb_interface *intf)
         kfree(hub->port_owners);
         kfree(hub->descriptor);
         kfree(hub->status);
-        usb_buffer_free(hub->hdev, sizeof(*hub->buffer), hub->buffer,
-                        hub->buffer_dma);
+        kfree(hub->buffer);
 
         kref_put(&hub->kref, hub_release);
 }
@@ -1178,6 +1218,9 @@ static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
         desc = intf->cur_altsetting;
         hdev = interface_to_usbdev(intf);
 
+        /* Hubs have proper suspend/resume support */
+        usb_enable_autosuspend(hdev);
+
         if (hdev->level == MAX_TOPO_LEVEL) {
                 dev_err(&intf->dev,
                         "Unsupported bus topology: hub nested too deep\n");
@@ -1356,10 +1399,8 @@ static void recursively_mark_NOTATTACHED(struct usb_device *udev)
                 if (udev->children[i])
                         recursively_mark_NOTATTACHED(udev->children[i]);
         }
-        if (udev->state == USB_STATE_SUSPENDED) {
-                udev->discon_suspended = 1;
+        if (udev->state == USB_STATE_SUSPENDED)
                 udev->active_duration -= jiffies;
-        }
         udev->state = USB_STATE_NOTATTACHED;
 }
 
@@ -1402,11 +1443,11 @@ void usb_set_device_state(struct usb_device *udev,
                                         || new_state == USB_STATE_SUSPENDED)
                                 ;       /* No change to wakeup settings */
                         else if (new_state == USB_STATE_CONFIGURED)
-                                device_init_wakeup(&udev->dev,
+                                device_set_wakeup_capable(&udev->dev,
                                         (udev->actconfig->desc.bmAttributes
                                          & USB_CONFIG_ATT_WAKEUP));
                         else
-                                device_init_wakeup(&udev->dev, 0);
+                                device_set_wakeup_capable(&udev->dev, 0);
                 }
                 if (udev->state == USB_STATE_SUSPENDED &&
                         new_state != USB_STATE_SUSPENDED)
@@ -1483,31 +1524,15 @@ static void update_address(struct usb_device *udev, int devnum)
                 udev->devnum = devnum;
 }
 
-#ifdef  CONFIG_USB_SUSPEND
-
-static void usb_stop_pm(struct usb_device *udev)
+static void hub_free_dev(struct usb_device *udev)
 {
-        /* Synchronize with the ksuspend thread to prevent any more
-         * autosuspend requests from being submitted, and decrement
-         * the parent's count of unsuspended children.
-         */
-        usb_pm_lock(udev);
-        if (udev->parent && !udev->discon_suspended)
-                usb_autosuspend_device(udev->parent);
-        usb_pm_unlock(udev);
+        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 
-        /* Stop any autosuspend or autoresume requests already submitted */
-        cancel_delayed_work_sync(&udev->autosuspend);
-        cancel_work_sync(&udev->autoresume);
+        /* Root hubs aren't real devices, so don't free HCD resources */
+        if (hcd->driver->free_dev && udev->parent)
+                hcd->driver->free_dev(hcd, udev);
 }
 
-#else
-
-static inline void usb_stop_pm(struct usb_device *udev)
-{ }
-
-#endif
-
 /**
  * usb_disconnect - disconnect a device (usbcore-internal)
  * @pdev: pointer to device being disconnected
@@ -1576,7 +1601,7 @@ void usb_disconnect(struct usb_device **pdev)
         *pdev = NULL;
         spin_unlock_irq(&device_state_lock);
 
-        usb_stop_pm(udev);
+        hub_free_dev(udev);
 
         put_device(&udev->dev);
 }
@@ -1612,12 +1637,12 @@ static inline void announce_device(struct usb_device *udev) { }
 #endif
 
 /**
- * usb_configure_device_otg - FIXME (usbcore-internal)
+ * usb_enumerate_device_otg - FIXME (usbcore-internal)
  * @udev: newly addressed device (in ADDRESS state)
  *
- * Do configuration for On-The-Go devices
+ * Finish enumeration for On-The-Go devices
  */
-static int usb_configure_device_otg(struct usb_device *udev)
+static int usb_enumerate_device_otg(struct usb_device *udev)
 {
         int err = 0;
 
@@ -1630,7 +1655,7 @@ static int usb_configure_device_otg(struct usb_device *udev)
         if (!udev->bus->is_b_host
                         && udev->config
                         && udev->parent == udev->bus->root_hub) {
-                struct usb_otg_descriptor       *desc = 0;
+                struct usb_otg_descriptor       *desc = NULL;
                 struct usb_bus                  *bus = udev->bus;
 
                 /* descriptor may appear anywhere in config */
@@ -1688,7 +1713,7 @@ fail:
 
 
 /**
- * usb_configure_device - Detect and probe device intfs/otg (usbcore-internal)
+ * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
  * @udev: newly addressed device (in ADDRESS state)
  *
  * This is only called by usb_new_device() and usb_authorize_device()
@@ -1699,7 +1724,7 @@ fail:
  * the string descriptors, as they will be errored out by the device
  * until it has been authorized.
  */
-static int usb_configure_device(struct usb_device *udev)
+static int usb_enumerate_device(struct usb_device *udev)
 {
         int err;
 
@@ -1723,7 +1748,7 @@ static int usb_configure_device(struct usb_device *udev)
                                                       udev->descriptor.iManufacturer);
                 udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
         }
-        err = usb_configure_device_otg(udev);
+        err = usb_enumerate_device_otg(udev);
 fail:
         return err;
 }
@@ -1733,8 +1758,8 @@ fail:
  * usb_new_device - perform initial device setup (usbcore-internal)
  * @udev: newly addressed device (in ADDRESS state)
  *
- * This is called with devices which have been enumerated, but not yet
- * configured.  The device descriptor is available, but not descriptors
+ * This is called with devices which have been detected but not fully
+ * enumerated.  The device descriptor is available, but not descriptors
  * for any device configuration.  The caller must have locked either
  * the parent hub (if udev is a normal device) or else the
  * usb_bus_list_lock (if udev is a root hub).  The parent's pointer to
@@ -1753,12 +1778,21 @@ int usb_new_device(struct usb_device *udev)
 {
         int err;
 
-        /* Increment the parent's count of unsuspended children */
-        if (udev->parent)
-                usb_autoresume_device(udev->parent);
+        if (udev->parent) {
+                /* Initialize non-root-hub device wakeup to disabled;
+                 * device (un)configuration controls wakeup capable
+                 * sysfs power/wakeup controls wakeup enabled/disabled
+                 */
+                device_init_wakeup(&udev->dev, 0);
+                device_set_wakeup_enable(&udev->dev, 1);
+        }
+
+        /* Tell the runtime-PM framework the device is active */
+        pm_runtime_set_active(&udev->dev);
+        pm_runtime_enable(&udev->dev);
 
-        usb_detect_quirks(udev);                /* Determine quirks */
-        err = usb_configure_device(udev);       /* detect & probe dev/intfs */
+        usb_detect_quirks(udev);
+        err = usb_enumerate_device(udev);       /* Read descriptors */
         if (err < 0)
                 goto fail;
         dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
@@ -1771,6 +1805,7 @@ int usb_new_device(struct usb_device *udev)
         /* Tell the world! */
         announce_device(udev);
 
+        device_enable_async_suspend(&udev->dev);
         /* Register the device.  The device driver is responsible
          * for configuring the device and invoking the add-device
          * notifier chain (used by usbfs and possibly others).
@@ -1786,7 +1821,8 @@ int usb_new_device(struct usb_device *udev)
 
 fail:
         usb_set_device_state(udev, USB_STATE_NOTATTACHED);
-        usb_stop_pm(udev);
+        pm_runtime_disable(&udev->dev);
+        pm_runtime_set_suspended(&udev->dev);
         return err;
 }
 
@@ -1803,21 +1839,23 @@ fail:
  */
 int usb_deauthorize_device(struct usb_device *usb_dev)
 {
-        unsigned cnt;
         usb_lock_device(usb_dev);
         if (usb_dev->authorized == 0)
                 goto out_unauthorized;
+
         usb_dev->authorized = 0;
         usb_set_configuration(usb_dev, -1);
+
+        kfree(usb_dev->product);
         usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
+        kfree(usb_dev->manufacturer);
         usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
+        kfree(usb_dev->serial);
         usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-        kfree(usb_dev->config);
-        usb_dev->config = NULL;
-        for (cnt = 0; cnt < usb_dev->descriptor.bNumConfigurations; cnt++)
-                kfree(usb_dev->rawdescriptors[cnt]);
+
+        usb_destroy_configuration(usb_dev);
         usb_dev->descriptor.bNumConfigurations = 0;
-        kfree(usb_dev->rawdescriptors);
+
 out_unauthorized:
         usb_unlock_device(usb_dev);
         return 0;
@@ -1827,15 +1865,11 @@ out_unauthorized:
 int usb_authorize_device(struct usb_device *usb_dev)
 {
         int result = 0, c;
+
         usb_lock_device(usb_dev);
         if (usb_dev->authorized == 1)
                 goto out_authorized;
-        kfree(usb_dev->product);
-        usb_dev->product = NULL;
-        kfree(usb_dev->manufacturer);
-        usb_dev->manufacturer = NULL;
-        kfree(usb_dev->serial);
-        usb_dev->serial = NULL;
+
         result = usb_autoresume_device(usb_dev);
         if (result < 0) {
                 dev_err(&usb_dev->dev,
@@ -1848,10 +1882,18 @@ int usb_authorize_device(struct usb_device *usb_dev)
                         "authorization: %d\n", result);
                 goto error_device_descriptor;
         }
+
+        kfree(usb_dev->product);
+        usb_dev->product = NULL;
+        kfree(usb_dev->manufacturer);
+        usb_dev->manufacturer = NULL;
+        kfree(usb_dev->serial);
+        usb_dev->serial = NULL;
+
         usb_dev->authorized = 1;
-        result = usb_configure_device(usb_dev);
+        result = usb_enumerate_device(usb_dev);
         if (result < 0)
-                goto error_configure;
+                goto error_enumerate;
         /* Choose and set the configuration.  This registers the interfaces
          * with the driver core and lets interface drivers bind to them.
          */
@@ -1866,8 +1908,10 @@ int usb_authorize_device(struct usb_device *usb_dev)
                 }
         }
         dev_info(&usb_dev->dev, "authorized to connect\n");
-error_configure:
+
+error_enumerate:
 error_device_descriptor:
+        usb_autosuspend_device(usb_dev);
 error_autoresume:
 out_authorized:
         usb_unlock_device(usb_dev);     // complements locktree
@@ -1927,7 +1971,7 @@ static int hub_port_wait_reset(struct usb_hub *hub, int port1,
                 if (!(portstatus & USB_PORT_STAT_RESET) &&
                     (portstatus & USB_PORT_STAT_ENABLE)) {
                         if (hub_is_wusb(hub))
-                                udev->speed = USB_SPEED_VARIABLE;
+                                udev->speed = USB_SPEED_WIRELESS;
                         else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
                                 udev->speed = USB_SPEED_HIGH;
                         else if (portstatus & USB_PORT_STAT_LOW_SPEED)
@@ -1953,7 +1997,9 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                                 struct usb_device *udev, unsigned int delay)
 {
         int i, status;
+        struct usb_hcd *hcd;
 
+        hcd = bus_to_hcd(udev->bus);
         /* Block EHCI CF initialization during the port reset.
          * Some companion controllers don't like it when they mix.
          */
@@ -1981,6 +2027,14 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                         /* TRSTRCY = 10 ms; plus some extra */
                         msleep(10 + 40);
                         update_address(udev, 0);
+                        if (hcd->driver->reset_device) {
+                                status = hcd->driver->reset_device(hcd, udev);
+                                if (status < 0) {
+                                        dev_err(&udev->dev, "Cannot reset "
+                                                        "HCD device state\n");
+                                        break;
+                                }
+                        }
                         /* FALL THROUGH */
                 case -ENOTCONN:
                 case -ENODEV:
@@ -2123,9 +2177,13 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                                 USB_DEVICE_REMOTE_WAKEUP, 0,
                                 NULL, 0,
                                 USB_CTRL_SET_TIMEOUT);
-                if (status)
+                if (status) {
                         dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
                                         status);
+                        /* bail if autosuspend is requested */
+                        if (msg.event & PM_EVENT_AUTO)
+                                return status;
+                }
         }
 
         /* see 7.1.7.6 */
@@ -2134,7 +2192,8 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                 dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
                                 port1, status);
                 /* paranoia:  "should not happen" */
-                (void) usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                if (udev->do_remote_wakeup)
+                        (void) usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                                 USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
                                 USB_DEVICE_REMOTE_WAKEUP, 0,
                                 NULL, 0,
@@ -2321,14 +2380,17 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 }
 
 /* caller has locked udev */
-static int remote_wakeup(struct usb_device *udev)
+int usb_remote_wakeup(struct usb_device *udev)
 {
         int     status = 0;
 
         if (udev->state == USB_STATE_SUSPENDED) {
                 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
-                usb_mark_last_busy(udev);
-                status = usb_external_resume_device(udev, PMSG_REMOTE_RESUME);
+                status = usb_autoresume_device(udev);
+                if (status == 0) {
+                        /* Let the drivers do their thing, then... */
+                        usb_autosuspend_device(udev);
+                }
         }
         return status;
 }
@@ -2365,11 +2427,6 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         return status;
 }
 
-static inline int remote_wakeup(struct usb_device *udev)
-{
-        return 0;
-}
-
 #endif
 
 static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
@@ -2436,11 +2493,6 @@ EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
 
 #else   /* CONFIG_PM */
 
-static inline int remote_wakeup(struct usb_device *udev)
-{
-        return 0;
-}
-
 #define hub_suspend             NULL
 #define hub_resume              NULL
 #define hub_reset_resume        NULL
@@ -2585,14 +2637,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
 
         mutex_lock(&usb_address0_mutex);
 
-        if ((hcd->driver->flags & HCD_USB3) && udev->config) {
-                /* FIXME this will need special handling by the xHCI driver. */
-                dev_dbg(&udev->dev,
-                                "xHCI reset of configured device "
-                                "not supported yet.\n");
-                retval = -EINVAL;
-                goto fail;
-        } else if (!udev->config && oldspeed == USB_SPEED_SUPER) {
+        if (!udev->config && oldspeed == USB_SPEED_SUPER) {
                 /* Don't reset USB 3.0 devices during an initial setup */
                 usb_set_device_state(udev, USB_STATE_DEFAULT);
         } else {
@@ -2618,7 +2663,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
          */
         switch (udev->speed) {
         case USB_SPEED_SUPER:
-        case USB_SPEED_VARIABLE:        /* fixed at 512 */
+        case USB_SPEED_WIRELESS:        /* fixed at 512 */
                 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
                 break;
         case USB_SPEED_HIGH:            /* fixed at 64 */
@@ -2646,7 +2691,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         case USB_SPEED_SUPER:
                                 speed = "super";
                                 break;
-        case USB_SPEED_VARIABLE:
+        case USB_SPEED_WIRELESS:
                                 speed = "variable";
                                 type = "Wireless ";
                                 break;
@@ -2946,7 +2991,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                         /* For a suspended device, treat this as a
                          * remote wakeup event.
                          */
-                        status = remote_wakeup(udev);
+                        status = usb_remote_wakeup(udev);
 #endif
 
                 } else {
@@ -2965,6 +3010,13 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 usb_disconnect(&hdev->children[port1-1]);
         clear_bit(port1, hub->change_bits);
 
+        /* We can forget about a "removed" device when there's a physical
+         * disconnect or the connect status changes.
+         */
+        if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
+                        (portchange & USB_PORT_STAT_C_CONNECTION))
+                clear_bit(port1, hub->removed_bits);
+
         if (portchange & (USB_PORT_STAT_C_CONNECTION |
                                 USB_PORT_STAT_C_ENABLE)) {
                 status = hub_port_debounce(hub, port1);
@@ -2978,8 +3030,11 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 }
         }
 
-        /* Return now if debouncing failed or nothing is connected */
-        if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
+        /* Return now if debouncing failed or nothing is connected or
+         * the device was "removed".
+         */
+        if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
+                        test_bit(port1, hub->removed_bits)) {
 
                 /* maybe switch power back on (e.g. root hub was reset) */
                 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
@@ -3122,6 +3177,7 @@ loop_disable:
 loop:
                 usb_ep0_reinit(udev);
                 release_address(udev);
+                hub_free_dev(udev);
                 usb_put_dev(udev);
                 if ((status == -ENOTCONN) || (status == -ENOTSUPP))
                         break;
@@ -3189,7 +3245,7 @@ static void hub_events(void)
                  * disconnected while waiting for the lock to succeed. */
                 usb_lock_device(hdev);
                 if (unlikely(hub->disconnected))
-                        goto loop;
+                        goto loop_disconnected;
 
                 /* If the hub has died, clean up after it */
                 if (hdev->state == USB_STATE_NOTATTACHED) {
@@ -3278,8 +3334,11 @@ static void hub_events(void)
                                         USB_PORT_FEAT_C_SUSPEND);
                                 udev = hdev->children[i-1];
                                 if (udev) {
+                                        /* TRSMRCY = 10 msec */
+                                        msleep(10);
+
                                         usb_lock_device(udev);
-                                        ret = remote_wakeup(hdev->
+                                        ret = usb_remote_wakeup(hdev->
                                                         children[i-1]);
                                         usb_unlock_device(udev);
                                         if (ret < 0)
@@ -3338,11 +3397,15 @@ static void hub_events(void)
                         }
                 }
 
-loop_autopm:
-                /* Allow autosuspend if we're not going to run again */
-                if (list_empty(&hub->event_list))
-                        usb_autopm_enable(intf);
-loop:
+ loop_autopm:
+                /* Balance the usb_autopm_get_interface() above */
+                usb_autopm_put_interface_no_suspend(intf);
+ loop:
+                /* Balance the usb_autopm_get_interface_no_resume() in
+                 * kick_khubd() and allow autosuspend.
+                 */
+                usb_autopm_put_interface(intf);
+ loop_disconnected:
                 usb_unlock_device(hdev);
                 kref_put(&hub->kref, hub_release);
 
@@ -3369,7 +3432,7 @@ static int hub_thread(void *__unused)
         return 0;
 }
 
-static struct usb_device_id hub_id_table [] = {
+static const struct usb_device_id hub_id_table[] = {
     { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
       .bDeviceClass = USB_CLASS_HUB},
     { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
@@ -3534,6 +3597,7 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
 {
         struct usb_device               *parent_hdev = udev->parent;
         struct usb_hub                  *parent_hub;
+        struct usb_hcd                  *hcd = bus_to_hcd(udev->bus);
         struct usb_device_descriptor    descriptor = udev->descriptor;
         int                             i, ret = 0;
         int                             port1 = udev->portnum;
@@ -3577,6 +3641,16 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
         /* Restore the device's previous configuration */
         if (!udev->actconfig)
                 goto done;
+
+        mutex_lock(&hcd->bandwidth_mutex);
+        ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
+        if (ret < 0) {
+                dev_warn(&udev->dev,
+                                "Busted HC?  Not enough HCD resources for "
+                                "old configuration.\n");
+                mutex_unlock(&hcd->bandwidth_mutex);
+                goto re_enumerate;
+        }
         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                         USB_REQ_SET_CONFIGURATION, 0,
                         udev->actconfig->desc.bConfigurationValue, 0,
@@ -3585,8 +3659,10 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 dev_err(&udev->dev,
                         "can't restore configuration #%d (error=%d)\n",
                         udev->actconfig->desc.bConfigurationValue, ret);
+                mutex_unlock(&hcd->bandwidth_mutex);
                 goto re_enumerate;
         }
+        mutex_unlock(&hcd->bandwidth_mutex);
         usb_set_device_state(udev, USB_STATE_CONFIGURED);
 
         /* Put interfaces back into the same altsettings as before.
@@ -3596,7 +3672,8 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
          * endpoint state.
          */
         for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
-                struct usb_interface *intf = udev->actconfig->interface[i];
+                struct usb_host_config *config = udev->actconfig;
+                struct usb_interface *intf = config->interface[i];
                 struct usb_interface_descriptor *desc;
 
                 desc = &intf->cur_altsetting->desc;
@@ -3605,8 +3682,14 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                         usb_enable_interface(udev, intf, true);
                         ret = 0;
                 } else {
+                        /* Let the bandwidth allocation function know that this
+                         * device has been reset, and it will have to use
+                         * alternate setting 0 as the current alternate setting.
+                         */
+                        intf->resetting_device = 1;
                         ret = usb_set_interface(udev, desc->bInterfaceNumber,
                                         desc->bAlternateSetting);
+                        intf->resetting_device = 0;
                 }
                 if (ret < 0) {
                         dev_err(&udev->dev, "failed to restore interface %d "
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 97b40ce133f0..111a01a747fc 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -380,6 +380,7 @@ static int usbfs_rmdir(struct inode *dir, struct dentry *dentry)
         mutex_lock(&inode->i_mutex);
         dentry_unhash(dentry);
         if (usbfs_empty(dentry)) {
+                dont_mount(dentry);
                 drop_nlink(dentry->d_inode);
                 drop_nlink(dentry->d_inode);
                 dput(dentry);
@@ -515,13 +516,13 @@ static int fs_create_by_name (const char *name, mode_t mode,
         *dentry = NULL;
         mutex_lock(&parent->d_inode->i_mutex);
         *dentry = lookup_one_len(name, parent, strlen(name));
-        if (!IS_ERR(dentry)) {
+        if (!IS_ERR(*dentry)) {
                 if ((mode & S_IFMT) == S_IFDIR)
                         error = usbfs_mkdir (parent->d_inode, *dentry, mode);
                 else 
                         error = usbfs_create (parent->d_inode, *dentry, mode);
         } else
-                error = PTR_ERR(dentry);
+                error = PTR_ERR(*dentry);
         mutex_unlock(&parent->d_inode->i_mutex);
 
         return error;
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index da718e84d58d..cd220277c6c3 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -393,13 +393,7 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
         if (io->entries <= 0)
                 return io->entries;
 
-        /* If we're running on an xHCI host controller, queue the whole scatter
-         * gather list with one call to urb_enqueue().  This is only for bulk,
-         * as that endpoint type does not care how the data gets broken up
-         * across frames.
-         */
-        if (usb_pipebulk(pipe) &&
-                        bus_to_hcd(dev->bus)->driver->flags & HCD_USB3) {
+        if (dev->bus->sg_tablesize > 0) {
                 io->urbs = kmalloc(sizeof *io->urbs, mem_flags);
                 use_sg = true;
         } else {
@@ -409,7 +403,7 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
         if (!io->urbs)
                 goto nomem;
 
-        urb_flags = URB_NO_INTERRUPT;
+        urb_flags = 0;
         if (dma)
                 urb_flags |= URB_NO_TRANSFER_DMA_MAP;
         if (usb_pipein(pipe))
@@ -441,6 +435,7 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
                 io->urbs[0]->num_sgs = io->entries;
                 io->entries = 1;
         } else {
+                urb_flags |= URB_NO_INTERRUPT;
                 for_each_sg(sg, sg, io->entries, i) {
                         unsigned len;
 
@@ -911,11 +906,11 @@ char *usb_cache_string(struct usb_device *udev, int index)
         if (index <= 0)
                 return NULL;
 
-        buf = kmalloc(MAX_USB_STRING_SIZE, GFP_KERNEL);
+        buf = kmalloc(MAX_USB_STRING_SIZE, GFP_NOIO);
         if (buf) {
                 len = usb_string(udev, index, buf, MAX_USB_STRING_SIZE);
                 if (len > 0) {
-                        smallbuf = kmalloc(++len, GFP_KERNEL);
+                        smallbuf = kmalloc(++len, GFP_NOIO);
                         if (!smallbuf)
                                 return buf;
                         memcpy(smallbuf, buf, len);
@@ -1303,6 +1298,7 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 {
         struct usb_interface *iface;
         struct usb_host_interface *alt;
+        struct usb_hcd *hcd = bus_to_hcd(dev->bus);
         int ret;
         int manual = 0;
         unsigned int epaddr;
@@ -1320,11 +1316,23 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 
         alt = usb_altnum_to_altsetting(iface, alternate);
         if (!alt) {
-                dev_warn(&dev->dev, "selecting invalid altsetting %d",
+                dev_warn(&dev->dev, "selecting invalid altsetting %d\n",
                          alternate);
                 return -EINVAL;
         }
 
+        /* Make sure we have enough bandwidth for this alternate interface.
+         * Remove the current alt setting and add the new alt setting.
+         */
+        mutex_lock(&hcd->bandwidth_mutex);
+        ret = usb_hcd_alloc_bandwidth(dev, NULL, iface->cur_altsetting, alt);
+        if (ret < 0) {
+                dev_info(&dev->dev, "Not enough bandwidth for altsetting %d\n",
+                                alternate);
+                mutex_unlock(&hcd->bandwidth_mutex);
+                return ret;
+        }
+
         if (dev->quirks & USB_QUIRK_NO_SET_INTF)
                 ret = -EPIPE;
         else
@@ -1340,8 +1348,13 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
                         "manual set_interface for iface %d, alt %d\n",
                         interface, alternate);
                 manual = 1;
-        } else if (ret < 0)
+        } else if (ret < 0) {
+                /* Re-instate the old alt setting */
+                usb_hcd_alloc_bandwidth(dev, NULL, alt, iface->cur_altsetting);
+                mutex_unlock(&hcd->bandwidth_mutex);
                 return ret;
+        }
+        mutex_unlock(&hcd->bandwidth_mutex);
 
         /* FIXME drivers shouldn't need to replicate/bugfix the logic here
          * when they implement async or easily-killable versions of this or
@@ -1423,6 +1436,7 @@ int usb_reset_configuration(struct usb_device *dev)
 {
         int                     i, retval;
         struct usb_host_config  *config;
+        struct usb_hcd *hcd = bus_to_hcd(dev->bus);
 
         if (dev->state == USB_STATE_SUSPENDED)
                 return -EHOSTUNREACH;
@@ -1438,12 +1452,46 @@ int usb_reset_configuration(struct usb_device *dev)
         }
 
         config = dev->actconfig;
+        retval = 0;
+        mutex_lock(&hcd->bandwidth_mutex);
+        /* Make sure we have enough bandwidth for each alternate setting 0 */
+        for (i = 0; i < config->desc.bNumInterfaces; i++) {
+                struct usb_interface *intf = config->interface[i];
+                struct usb_host_interface *alt;
+
+                alt = usb_altnum_to_altsetting(intf, 0);
+                if (!alt)
+                        alt = &intf->altsetting[0];
+                if (alt != intf->cur_altsetting)
+                        retval = usb_hcd_alloc_bandwidth(dev, NULL,
+                                        intf->cur_altsetting, alt);
+                if (retval < 0)
+                        break;
+        }
+        /* If not, reinstate the old alternate settings */
+        if (retval < 0) {
+reset_old_alts:
+                for (i--; i >= 0; i--) {
+                        struct usb_interface *intf = config->interface[i];
+                        struct usb_host_interface *alt;
+
+                        alt = usb_altnum_to_altsetting(intf, 0);
+                        if (!alt)
+                                alt = &intf->altsetting[0];
+                        if (alt != intf->cur_altsetting)
+                                usb_hcd_alloc_bandwidth(dev, NULL,
+                                                alt, intf->cur_altsetting);
+                }
+                mutex_unlock(&hcd->bandwidth_mutex);
+                return retval;
+        }
         retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                         USB_REQ_SET_CONFIGURATION, 0,
                         config->desc.bConfigurationValue, 0,
                         NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (retval < 0)
-                return retval;
+                goto reset_old_alts;
+        mutex_unlock(&hcd->bandwidth_mutex);
 
         /* re-init hc/hcd interface/endpoint state */
         for (i = 0; i < config->desc.bNumInterfaces; i++) {
@@ -1585,7 +1633,7 @@ static struct usb_interface_assoc_descriptor *find_iad(struct usb_device *dev,
  *
  * See usb_queue_reset_device() for more details
  */
-void __usb_queue_reset_device(struct work_struct *ws)
+static void __usb_queue_reset_device(struct work_struct *ws)
 {
         int rc;
         struct usb_interface *iface =
@@ -1652,6 +1700,7 @@ int usb_set_configuration(struct usb_device *dev, int configuration)
         int i, ret;
         struct usb_host_config *cp = NULL;
         struct usb_interface **new_interfaces = NULL;
+        struct usb_hcd *hcd = bus_to_hcd(dev->bus);
         int n, nintf;
 
         if (dev->authorized == 0 || configuration == -1)
@@ -1682,7 +1731,7 @@ int usb_set_configuration(struct usb_device *dev, int configuration)
         if (cp) {
                 nintf = cp->desc.bNumInterfaces;
                 new_interfaces = kmalloc(nintf * sizeof(*new_interfaces),
-                                GFP_KERNEL);
+                                GFP_NOIO);
                 if (!new_interfaces) {
                         dev_err(&dev->dev, "Out of memory\n");
                         return -ENOMEM;
@@ -1691,7 +1740,7 @@ int usb_set_configuration(struct usb_device *dev, int configuration)
                 for (; n < nintf; ++n) {
                         new_interfaces[n] = kzalloc(
                                         sizeof(struct usb_interface),
-                                        GFP_KERNEL);
+                                        GFP_NOIO);
                         if (!new_interfaces[n]) {
                                 dev_err(&dev->dev, "Out of memory\n");
                                 ret = -ENOMEM;
@@ -1721,12 +1770,11 @@ free_interfaces:
          * host controller will not allow submissions to dropped endpoints.  If
          * this call fails, the device state is unchanged.
          */
-        if (cp)
-                ret = usb_hcd_check_bandwidth(dev, cp, NULL);
-        else
-                ret = usb_hcd_check_bandwidth(dev, NULL, NULL);
+        mutex_lock(&hcd->bandwidth_mutex);
+        ret = usb_hcd_alloc_bandwidth(dev, cp, NULL, NULL);
         if (ret < 0) {
                 usb_autosuspend_device(dev);
+                mutex_unlock(&hcd->bandwidth_mutex);
                 goto free_interfaces;
         }
 
@@ -1752,10 +1800,12 @@ free_interfaces:
         dev->actconfig = cp;
         if (!cp) {
                 usb_set_device_state(dev, USB_STATE_ADDRESS);
-                usb_hcd_check_bandwidth(dev, NULL, NULL);
+                usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
                 usb_autosuspend_device(dev);
+                mutex_unlock(&hcd->bandwidth_mutex);
                 goto free_interfaces;
         }
+        mutex_unlock(&hcd->bandwidth_mutex);
         usb_set_device_state(dev, USB_STATE_CONFIGURED);
 
         /* Initialize the new interface structures and the
@@ -1793,7 +1843,6 @@ free_interfaces:
                 intf->dev.dma_mask = dev->dev.dma_mask;
                 INIT_WORK(&intf->reset_ws, __usb_queue_reset_device);
                 device_initialize(&intf->dev);
-                mark_quiesced(intf);
                 dev_set_name(&intf->dev, "%d-%s:%d.%d",
                         dev->bus->busnum, dev->devpath,
                         configuration, alt->desc.bInterfaceNumber);
@@ -1817,6 +1866,7 @@ free_interfaces:
                         "adding %s (config #%d, interface %d)\n",
                         dev_name(&intf->dev), configuration,
                         intf->cur_altsetting->desc.bInterfaceNumber);
+                device_enable_async_suspend(&intf->dev);
                 ret = device_add(&intf->dev);
                 if (ret != 0) {
                         dev_err(&dev->dev, "device_add(%s) --> %d\n",
@@ -1890,7 +1940,7 @@ static void cancel_async_set_config(struct usb_device *udev)
  * routine gets around the normal restrictions by using a work thread to
  * submit the change-config request.
  *
- * Returns 0 if the request was succesfully queued, error code otherwise.
+ * Returns 0 if the request was successfully queued, error code otherwise.
  * The caller has no way to know whether the queued request will eventually
  * succeed.
  */
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index ab93918d9207..f073c5cb4e7b 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -103,10 +103,19 @@ void usb_detect_quirks(struct usb_device *udev)
                 dev_dbg(&udev->dev, "USB quirks for this device: %x\n",
                                 udev->quirks);
 
-        /* By default, disable autosuspend for all non-hubs */
 #ifdef  CONFIG_USB_SUSPEND
-        if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
-                udev->autosuspend_disabled = 1;
+
+        /* By default, disable autosuspend for all devices.  The hub driver
+         * will enable it for hubs.
+         */
+        usb_disable_autosuspend(udev);
+
+        /* Autosuspend can also be disabled if the initial autosuspend_delay
+         * is negative.
+         */
+        if (udev->autosuspend_delay < 0)
+                usb_autoresume_device(udev);
+
 #endif
 
         /* For the present, all devices default to USB-PERSIST enabled */
@@ -120,6 +129,7 @@ void usb_detect_quirks(struct usb_device *udev)
          * for all devices.  It will affect things like hub resets
          * and EMF-related port disables.
          */
-        udev->persist_enabled = 1;
+        if (!(udev->quirks & USB_QUIRK_RESET_MORPHS))
+                udev->persist_enabled = 1;
 #endif  /* CONFIG_PM */
 }
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 7ec3041ae79e..43c002e3a9aa 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -82,9 +82,13 @@ static ssize_t  show_##name(struct device *dev,				\
                 struct device_attribute *attr, char *buf)               \
 {                                                                       \
         struct usb_device *udev;                                        \
+        int retval;                                                     \
                                                                         \
         udev = to_usb_device(dev);                                      \
-        return sprintf(buf, "%s\n", udev->name);                        \
+        usb_lock_device(udev);                                          \
+        retval = sprintf(buf, "%s\n", udev->name);                      \
+        usb_unlock_device(udev);                                        \
+        return retval;                                                  \
 }                                                                       \
 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
 
@@ -111,6 +115,12 @@ show_speed(struct device *dev, struct device_attribute *attr, char *buf)
         case USB_SPEED_HIGH:
                 speed = "480";
                 break;
+        case USB_SPEED_WIRELESS:
+                speed = "480";
+                break;
+        case USB_SPEED_SUPER:
+                speed = "5000";
+                break;
         default:
                 speed = "unknown";
         }
@@ -139,6 +149,16 @@ show_devnum(struct device *dev, struct device_attribute *attr, char *buf)
 static DEVICE_ATTR(devnum, S_IRUGO, show_devnum, NULL);
 
 static ssize_t
+show_devpath(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct usb_device *udev;
+
+        udev = to_usb_device(dev);
+        return sprintf(buf, "%s\n", udev->devpath);
+}
+static DEVICE_ATTR(devpath, S_IRUGO, show_devpath, NULL);
+
+static ssize_t
 show_version(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct usb_device *udev;
@@ -171,6 +191,36 @@ show_quirks(struct device *dev, struct device_attribute *attr, char *buf)
 static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL);
 
 static ssize_t
+show_avoid_reset_quirk(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct usb_device *udev;
+
+        udev = to_usb_device(dev);
+        return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET_MORPHS));
+}
+
+static ssize_t
+set_avoid_reset_quirk(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct usb_device       *udev = to_usb_device(dev);
+        int                     config;
+
+        if (sscanf(buf, "%d", &config) != 1 || config < 0 || config > 1)
+                return -EINVAL;
+        usb_lock_device(udev);
+        if (config)
+                udev->quirks |= USB_QUIRK_RESET_MORPHS;
+        else
+                udev->quirks &= ~USB_QUIRK_RESET_MORPHS;
+        usb_unlock_device(udev);
+        return count;
+}
+
+static DEVICE_ATTR(avoid_reset_quirk, S_IRUGO | S_IWUSR,
+                show_avoid_reset_quirk, set_avoid_reset_quirk);
+
+static ssize_t
 show_urbnum(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct usb_device *udev;
@@ -206,9 +256,10 @@ set_persist(struct device *dev, struct device_attribute *attr,
 
         if (sscanf(buf, "%d", &value) != 1)
                 return -EINVAL;
-        usb_pm_lock(udev);
+
+        usb_lock_device(udev);
         udev->persist_enabled = !!value;
-        usb_pm_unlock(udev);
+        usb_unlock_device(udev);
         return count;
 }
 
@@ -295,20 +346,34 @@ set_autosuspend(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
         struct usb_device *udev = to_usb_device(dev);
-        int value;
+        int value, old_delay;
+        int rc;
 
         if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/HZ ||
                         value <= - INT_MAX/HZ)
                 return -EINVAL;
         value *= HZ;
 
+        usb_lock_device(udev);
+        old_delay = udev->autosuspend_delay;
         udev->autosuspend_delay = value;
-        if (value >= 0)
-                usb_try_autosuspend_device(udev);
-        else {
-                if (usb_autoresume_device(udev) == 0)
+
+        if (old_delay < 0) {    /* Autosuspend wasn't allowed */
+                if (value >= 0)
                         usb_autosuspend_device(udev);
+        } else {                /* Autosuspend was allowed */
+                if (value < 0) {
+                        rc = usb_autoresume_device(udev);
+                        if (rc < 0) {
+                                count = rc;
+                                udev->autosuspend_delay = old_delay;
+                        }
+                } else {
+                        usb_try_autosuspend_device(udev);
+                }
         }
+
+        usb_unlock_device(udev);
         return count;
 }
 
@@ -317,7 +382,6 @@ static DEVICE_ATTR(autosuspend, S_IRUGO | S_IWUSR,
 
 static const char on_string[] = "on";
 static const char auto_string[] = "auto";
-static const char suspend_string[] = "suspend";
 
 static ssize_t
 show_level(struct device *dev, struct device_attribute *attr, char *buf)
@@ -325,13 +389,8 @@ show_level(struct device *dev, struct device_attribute *attr, char *buf)
         struct usb_device *udev = to_usb_device(dev);
         const char *p = auto_string;
 
-        if (udev->state == USB_STATE_SUSPENDED) {
-                if (udev->autoresume_disabled)
-                        p = suspend_string;
-        } else {
-                if (udev->autosuspend_disabled)
-                        p = on_string;
-        }
+        if (udev->state != USB_STATE_SUSPENDED && udev->autosuspend_disabled)
+                p = on_string;
         return sprintf(buf, "%s\n", p);
 }
 
@@ -342,45 +401,25 @@ set_level(struct device *dev, struct device_attribute *attr,
         struct usb_device *udev = to_usb_device(dev);
         int len = count;
         char *cp;
-        int rc = 0;
-        int old_autosuspend_disabled, old_autoresume_disabled;
+        int rc;
 
         cp = memchr(buf, '\n', count);
         if (cp)
                 len = cp - buf;
 
         usb_lock_device(udev);
-        old_autosuspend_disabled = udev->autosuspend_disabled;
-        old_autoresume_disabled = udev->autoresume_disabled;
 
-        /* Setting the flags without calling usb_pm_lock is a subject to
-         * races, but who cares...
-         */
         if (len == sizeof on_string - 1 &&
-                        strncmp(buf, on_string, len) == 0) {
-                udev->autosuspend_disabled = 1;
-                udev->autoresume_disabled = 0;
-                rc = usb_external_resume_device(udev, PMSG_USER_RESUME);
-
-        } else if (len == sizeof auto_string - 1 &&
-                        strncmp(buf, auto_string, len) == 0) {
-                udev->autosuspend_disabled = 0;
-                udev->autoresume_disabled = 0;
-                rc = usb_external_resume_device(udev, PMSG_USER_RESUME);
-
-        } else if (len == sizeof suspend_string - 1 &&
-                        strncmp(buf, suspend_string, len) == 0) {
-                udev->autosuspend_disabled = 0;
-                udev->autoresume_disabled = 1;
-                rc = usb_external_suspend_device(udev, PMSG_USER_SUSPEND);
-
-        } else
+                        strncmp(buf, on_string, len) == 0)
+                rc = usb_disable_autosuspend(udev);
+
+        else if (len == sizeof auto_string - 1 &&
+                        strncmp(buf, auto_string, len) == 0)
+                rc = usb_enable_autosuspend(udev);
+
+        else
                 rc = -EINVAL;
 
-        if (rc) {
-                udev->autosuspend_disabled = old_autosuspend_disabled;
-                udev->autoresume_disabled = old_autoresume_disabled;
-        }
         usb_unlock_device(udev);
         return (rc < 0 ? rc : count);
 }
@@ -508,6 +547,28 @@ static ssize_t usb_dev_authorized_store(struct device *dev,
 static DEVICE_ATTR(authorized, 0644,
             usb_dev_authorized_show, usb_dev_authorized_store);
 
+/* "Safely remove a device" */
+static ssize_t usb_remove_store(struct device *dev,
+                struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct usb_device *udev = to_usb_device(dev);
+        int rc = 0;
+
+        usb_lock_device(udev);
+        if (udev->state != USB_STATE_NOTATTACHED) {
+
+                /* To avoid races, first unconfigure and then remove */
+                usb_set_configuration(udev, -1);
+                rc = usb_remove_device(udev);
+        }
+        if (rc == 0)
+                rc = count;
+        usb_unlock_device(udev);
+        return rc;
+}
+static DEVICE_ATTR(remove, 0200, NULL, usb_remove_store);
+
 
 static struct attribute *dev_attrs[] = {
         /* current configuration's attributes */
@@ -516,8 +577,8 @@ static struct attribute *dev_attrs[] = {
         &dev_attr_bConfigurationValue.attr,
         &dev_attr_bmAttributes.attr,
         &dev_attr_bMaxPower.attr,
-        &dev_attr_urbnum.attr,
         /* device attributes */
+        &dev_attr_urbnum.attr,
         &dev_attr_idVendor.attr,
         &dev_attr_idProduct.attr,
         &dev_attr_bcdDevice.attr,
@@ -529,10 +590,13 @@ static struct attribute *dev_attrs[] = {
         &dev_attr_speed.attr,
         &dev_attr_busnum.attr,
         &dev_attr_devnum.attr,
+        &dev_attr_devpath.attr,
         &dev_attr_version.attr,
         &dev_attr_maxchild.attr,
         &dev_attr_quirks.attr,
+        &dev_attr_avoid_reset_quirk.attr,
         &dev_attr_authorized.attr,
+        &dev_attr_remove.attr,
         NULL,
 };
 static struct attribute_group dev_attr_grp = {
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index 0885d4abdc62..45a32dadb406 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -387,6 +387,13 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
         {
         unsigned int    orig_flags = urb->transfer_flags;
         unsigned int    allowed;
+        static int pipetypes[4] = {
+                PIPE_CONTROL, PIPE_ISOCHRONOUS, PIPE_BULK, PIPE_INTERRUPT
+        };
+
+        /* Check that the pipe's type matches the endpoint's type */
+        if (usb_pipetype(urb->pipe) != pipetypes[xfertype])
+                return -EPIPE;          /* The most suitable error code :-) */
 
         /* enforce simple/standard policy */
         allowed = (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP |
@@ -429,8 +436,16 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
         case USB_ENDPOINT_XFER_ISOC:
         case USB_ENDPOINT_XFER_INT:
                 /* too small? */
-                if (urb->interval <= 0)
-                        return -EINVAL;
+                switch (dev->speed) {
+                case USB_SPEED_WIRELESS:
+                        if (urb->interval < 6)
+                                return -EINVAL;
+                        break;
+                default:
+                        if (urb->interval <= 0)
+                                return -EINVAL;
+                        break;
+                }
                 /* too big? */
                 switch (dev->speed) {
                 case USB_SPEED_SUPER:   /* units are 125us */
@@ -438,6 +453,11 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
                         if (urb->interval > (1 << 15))
                                 return -EINVAL;
                         max = 1 << 15;
+                        break;
+                case USB_SPEED_WIRELESS:
+                        if (urb->interval > 16)
+                                return -EINVAL;
+                        break;
                 case USB_SPEED_HIGH:    /* units are microframes */
                         /* NOTE usb handles 2^15 */
                         if (urb->interval > (1024 * 8))
@@ -461,8 +481,10 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
                 default:
                         return -EINVAL;
                 }
-                /* Round down to a power of 2, no more than max */
-                urb->interval = min(max, 1 << ilog2(urb->interval));
+                if (dev->speed != USB_SPEED_WIRELESS) {
+                        /* Round down to a power of 2, no more than max */
+                        urb->interval = min(max, 1 << ilog2(urb->interval));
+                }
         }
 
         return usb_hcd_submit_urb(urb, mem_flags);
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index b1b85abb9a2d..0561430f2ede 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -49,9 +49,6 @@ const char *usbcore_name = "usbcore";
 
 static int nousb;       /* Disable USB when built into kernel image */
 
-/* Workqueue for autosuspend and for remote wakeup of root hubs */
-struct workqueue_struct *ksuspend_usb_wq;
-
 #ifdef  CONFIG_USB_SUSPEND
 static int usb_autosuspend_delay = 2;           /* Default delay value,
                                                  * in seconds */
@@ -64,6 +61,43 @@ MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
 
 
 /**
+ * usb_find_alt_setting() - Given a configuration, find the alternate setting
+ * for the given interface.
+ * @config: the configuration to search (not necessarily the current config).
+ * @iface_num: interface number to search in
+ * @alt_num: alternate interface setting number to search for.
+ *
+ * Search the configuration's interface cache for the given alt setting.
+ */
+struct usb_host_interface *usb_find_alt_setting(
+                struct usb_host_config *config,
+                unsigned int iface_num,
+                unsigned int alt_num)
+{
+        struct usb_interface_cache *intf_cache = NULL;
+        int i;
+
+        for (i = 0; i < config->desc.bNumInterfaces; i++) {
+                if (config->intf_cache[i]->altsetting[0].desc.bInterfaceNumber
+                                == iface_num) {
+                        intf_cache = config->intf_cache[i];
+                        break;
+                }
+        }
+        if (!intf_cache)
+                return NULL;
+        for (i = 0; i < intf_cache->num_altsetting; i++)
+                if (intf_cache->altsetting[i].desc.bAlternateSetting == alt_num)
+                        return &intf_cache->altsetting[i];
+
+        printk(KERN_DEBUG "Did not find alt setting %u for intf %u, "
+                        "config %u\n", alt_num, iface_num,
+                        config->desc.bConfigurationValue);
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(usb_find_alt_setting);
+
+/**
  * usb_ifnum_to_if - get the interface object with a given interface number
  * @dev: the device whose current configuration is considered
  * @ifnum: the desired interface
@@ -132,7 +166,7 @@ EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);
 
 struct find_interface_arg {
         int minor;
-        struct usb_interface *interface;
+        struct device_driver *drv;
 };
 
 static int __find_interface(struct device *dev, void *data)
@@ -143,12 +177,10 @@ static int __find_interface(struct device *dev, void *data)
         if (!is_usb_interface(dev))
                 return 0;
 
+        if (dev->driver != arg->drv)
+                return 0;
         intf = to_usb_interface(dev);
-        if (intf->minor != -1 && intf->minor == arg->minor) {
-                arg->interface = intf;
-                return 1;
-        }
-        return 0;
+        return intf->minor == arg->minor;
 }
 
 /**
@@ -156,21 +188,24 @@ static int __find_interface(struct device *dev, void *data)
  * @drv: the driver whose current configuration is considered
  * @minor: the minor number of the desired device
  *
- * This walks the driver device list and returns a pointer to the interface
- * with the matching minor.  Note, this only works for devices that share the
- * USB major number.
+ * This walks the bus device list and returns a pointer to the interface
+ * with the matching minor and driver.  Note, this only works for devices
+ * that share the USB major number.
  */
 struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
 {
         struct find_interface_arg argb;
-        int retval;
+        struct device *dev;
 
         argb.minor = minor;
-        argb.interface = NULL;
-        /* eat the error, it will be in argb.interface */
-        retval = driver_for_each_device(&drv->drvwrap.driver, NULL, &argb,
-                                        __find_interface);
-        return argb.interface;
+        argb.drv = &drv->drvwrap.driver;
+
+        dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface);
+
+        /* Drop reference count from bus_find_device */
+        put_device(dev);
+
+        return dev ? to_usb_interface(dev) : NULL;
 }
 EXPORT_SYMBOL_GPL(usb_find_interface);
 
@@ -190,9 +225,6 @@ static void usb_release_dev(struct device *dev)
         hcd = bus_to_hcd(udev->bus);
 
         usb_destroy_configuration(udev);
-        /* Root hubs aren't real devices, so don't free HCD resources */
-        if (hcd->driver->free_dev && udev->parent)
-                hcd->driver->free_dev(hcd, udev);
         usb_put_hcd(hcd);
         kfree(udev->product);
         kfree(udev->manufacturer);
@@ -226,23 +258,6 @@ static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
 
 #ifdef  CONFIG_PM
 
-static int ksuspend_usb_init(void)
-{
-        /* This workqueue is supposed to be both freezable and
-         * singlethreaded.  Its job doesn't justify running on more
-         * than one CPU.
-         */
-        ksuspend_usb_wq = create_freezeable_workqueue("ksuspend_usbd");
-        if (!ksuspend_usb_wq)
-                return -ENOMEM;
-        return 0;
-}
-
-static void ksuspend_usb_cleanup(void)
-{
-        destroy_workqueue(ksuspend_usb_wq);
-}
-
 /* USB device Power-Management thunks.
  * There's no need to distinguish here between quiescing a USB device
  * and powering it down; the generic_suspend() routine takes care of
@@ -258,7 +273,7 @@ static int usb_dev_prepare(struct device *dev)
 static void usb_dev_complete(struct device *dev)
 {
         /* Currently used only for rebinding interfaces */
-        usb_resume(dev, PMSG_RESUME);   /* Message event is meaningless */
+        usb_resume(dev, PMSG_ON);       /* FIXME: change to PMSG_COMPLETE */
 }
 
 static int usb_dev_suspend(struct device *dev)
@@ -291,7 +306,7 @@ static int usb_dev_restore(struct device *dev)
         return usb_resume(dev, PMSG_RESTORE);
 }
 
-static struct dev_pm_ops usb_device_pm_ops = {
+static const struct dev_pm_ops usb_device_pm_ops = {
         .prepare =      usb_dev_prepare,
         .complete =     usb_dev_complete,
         .suspend =      usb_dev_suspend,
@@ -304,9 +319,7 @@ static struct dev_pm_ops usb_device_pm_ops = {
 
 #else
 
-#define ksuspend_usb_init()     0
-#define ksuspend_usb_cleanup()  do {} while (0)
-#define usb_device_pm_ops       (*(struct dev_pm_ops *)0)
+#define usb_device_pm_ops       (*(struct dev_pm_ops *) NULL)
 
 #endif  /* CONFIG_PM */
 
@@ -434,9 +447,6 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
         INIT_LIST_HEAD(&dev->filelist);
 
 #ifdef  CONFIG_PM
-        mutex_init(&dev->pm_mutex);
-        INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
-        INIT_WORK(&dev->autoresume, usb_autoresume_work);
         dev->autosuspend_delay = usb_autosuspend_delay * HZ;
         dev->connect_time = jiffies;
         dev->active_duration = -jiffies;
@@ -708,7 +718,7 @@ int __usb_get_extra_descriptor(char *buffer, unsigned size,
 EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);
 
 /**
- * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
+ * usb_alloc_coherent - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
  * @dev: device the buffer will be used with
  * @size: requested buffer size
  * @mem_flags: affect whether allocation may block
@@ -727,30 +737,30 @@ EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);
  * architectures where CPU caches are not DMA-coherent.  On systems without
  * bus-snooping caches, these buffers are uncached.
  *
- * When the buffer is no longer used, free it with usb_buffer_free().
+ * When the buffer is no longer used, free it with usb_free_coherent().
  */
-void *usb_buffer_alloc(struct usb_device *dev, size_t size, gfp_t mem_flags,
-                       dma_addr_t *dma)
+void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags,
+                         dma_addr_t *dma)
 {
         if (!dev || !dev->bus)
                 return NULL;
         return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
 }
-EXPORT_SYMBOL_GPL(usb_buffer_alloc);
+EXPORT_SYMBOL_GPL(usb_alloc_coherent);
 
 /**
- * usb_buffer_free - free memory allocated with usb_buffer_alloc()
+ * usb_free_coherent - free memory allocated with usb_alloc_coherent()
  * @dev: device the buffer was used with
  * @size: requested buffer size
  * @addr: CPU address of buffer
  * @dma: DMA address of buffer
  *
  * This reclaims an I/O buffer, letting it be reused.  The memory must have
- * been allocated using usb_buffer_alloc(), and the parameters must match
+ * been allocated using usb_alloc_coherent(), and the parameters must match
  * those provided in that allocation request.
  */
-void usb_buffer_free(struct usb_device *dev, size_t size, void *addr,
-                     dma_addr_t dma)
+void usb_free_coherent(struct usb_device *dev, size_t size, void *addr,
+                       dma_addr_t dma)
 {
         if (!dev || !dev->bus)
                 return;
@@ -758,7 +768,7 @@ void usb_buffer_free(struct usb_device *dev, size_t size, void *addr,
                 return;
         hcd_buffer_free(dev->bus, size, addr, dma);
 }
-EXPORT_SYMBOL_GPL(usb_buffer_free);
+EXPORT_SYMBOL_GPL(usb_free_coherent);
 
 /**
  * usb_buffer_map - create DMA mapping(s) for an urb
@@ -1038,7 +1048,7 @@ static struct notifier_block usb_bus_nb = {
 struct dentry *usb_debug_root;
 EXPORT_SYMBOL_GPL(usb_debug_root);
 
-struct dentry *usb_debug_devices;
+static struct dentry *usb_debug_devices;
 
 static int usb_debugfs_init(void)
 {
@@ -1079,9 +1089,6 @@ static int __init usb_init(void)
         if (retval)
                 goto out;
 
-        retval = ksuspend_usb_init();
-        if (retval)
-                goto out;
         retval = bus_register(&usb_bus_type);
         if (retval)
                 goto bus_register_failed;
@@ -1121,7 +1128,7 @@ major_init_failed:
 bus_notifier_failed:
         bus_unregister(&usb_bus_type);
 bus_register_failed:
-        ksuspend_usb_cleanup();
+        usb_debugfs_cleanup();
 out:
         return retval;
 }
@@ -1143,7 +1150,6 @@ static void __exit usb_exit(void)
         usb_hub_cleanup();
         bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
         bus_unregister(&usb_bus_type);
-        ksuspend_usb_cleanup();
         usb_debugfs_cleanup();
 }
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 9a8b15e6377a..cd882203ad34 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -24,6 +24,7 @@ extern void usb_disable_device(struct usb_device *dev, int skip_ep0);
 extern int usb_deauthorize_device(struct usb_device *);
 extern int usb_authorize_device(struct usb_device *);
 extern void usb_detect_quirks(struct usb_device *udev);
+extern int usb_remove_device(struct usb_device *udev);
 
 extern int usb_get_device_descriptor(struct usb_device *dev,
                 unsigned int size);
@@ -54,24 +55,8 @@ extern void usb_major_cleanup(void);
 extern int usb_suspend(struct device *dev, pm_message_t msg);
 extern int usb_resume(struct device *dev, pm_message_t msg);
 
-extern void usb_autosuspend_work(struct work_struct *work);
-extern void usb_autoresume_work(struct work_struct *work);
 extern int usb_port_suspend(struct usb_device *dev, pm_message_t msg);
 extern int usb_port_resume(struct usb_device *dev, pm_message_t msg);
-extern int usb_external_suspend_device(struct usb_device *udev,
-                pm_message_t msg);
-extern int usb_external_resume_device(struct usb_device *udev,
-                pm_message_t msg);
-
-static inline void usb_pm_lock(struct usb_device *udev)
-{
-        mutex_lock_nested(&udev->pm_mutex, udev->level);
-}
-
-static inline void usb_pm_unlock(struct usb_device *udev)
-{
-        mutex_unlock(&udev->pm_mutex);
-}
 
 #else
 
@@ -85,9 +70,6 @@ static inline int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         return 0;
 }
 
-static inline void usb_pm_lock(struct usb_device *udev) {}
-static inline void usb_pm_unlock(struct usb_device *udev) {}
-
 #endif
 
 #ifdef CONFIG_USB_SUSPEND
@@ -95,6 +77,7 @@ static inline void usb_pm_unlock(struct usb_device *udev) {}
 extern void usb_autosuspend_device(struct usb_device *udev);
 extern void usb_try_autosuspend_device(struct usb_device *udev);
 extern int usb_autoresume_device(struct usb_device *udev);
+extern int usb_remote_wakeup(struct usb_device *dev);
 
 #else
 
@@ -105,9 +88,13 @@ static inline int usb_autoresume_device(struct usb_device *udev)
         return 0;
 }
 
+static inline int usb_remote_wakeup(struct usb_device *udev)
+{
+        return 0;
+}
+
 #endif
 
-extern struct workqueue_struct *ksuspend_usb_wq;
 extern struct bus_type usb_bus_type;
 extern struct device_type usb_device_type;
 extern struct device_type usb_if_device_type;
@@ -137,23 +124,6 @@ static inline int is_usb_device_driver(struct device_driver *drv)
                         for_devices;
 }
 
-/* Interfaces and their "power state" are owned by usbcore */
-
-static inline void mark_active(struct usb_interface *f)
-{
-        f->is_active = 1;
-}
-
-static inline void mark_quiesced(struct usb_interface *f)
-{
-        f->is_active = 0;
-}
-
-static inline int is_active(const struct usb_interface *f)
-{
-        return f->is_active;
-}
-
 
 /* for labeling diagnostics */
 extern const char *usbcore_name;
diff --git a/drivers/usb/early/ehci-dbgp.c b/drivers/usb/early/ehci-dbgp.c
index 1206a26ef893..6e98a3697844 100644
--- a/drivers/usb/early/ehci-dbgp.c
+++ b/drivers/usb/early/ehci-dbgp.c
@@ -66,8 +66,6 @@ static struct ehci_dev ehci_dev;
 
 #define USB_DEBUG_DEVNUM 127
 
-#define DBGP_DATA_TOGGLE        0x8800
-
 #ifdef DBGP_DEBUG
 #define dbgp_printk printk
 static void dbgp_ehci_status(char *str)
@@ -88,11 +86,6 @@ static inline void dbgp_ehci_status(char *str) { }
 static inline void dbgp_printk(const char *fmt, ...) { }
 #endif
 
-static inline u32 dbgp_pid_update(u32 x, u32 tok)
-{
-        return ((x ^ DBGP_DATA_TOGGLE) & 0xffff00) | (tok & 0xff);
-}
-
 static inline u32 dbgp_len_update(u32 x, u32 len)
 {
         return (x & ~0x0f) | (len & 0x0f);
@@ -136,6 +129,19 @@ static inline u32 dbgp_len_update(u32 x, u32 len)
 
 #define DBGP_MAX_PACKET         8
 #define DBGP_TIMEOUT            (250 * 1000)
+#define DBGP_LOOPS              1000
+
+static inline u32 dbgp_pid_write_update(u32 x, u32 tok)
+{
+        static int data0 = USB_PID_DATA1;
+        data0 ^= USB_PID_DATA_TOGGLE;
+        return (x & 0xffff0000) | (data0 << 8) | (tok & 0xff);
+}
+
+static inline u32 dbgp_pid_read_update(u32 x, u32 tok)
+{
+        return (x & 0xffff0000) | (USB_PID_DATA0 << 8) | (tok & 0xff);
+}
 
 static int dbgp_wait_until_complete(void)
 {
@@ -180,7 +186,7 @@ static int dbgp_wait_until_done(unsigned ctrl)
 {
         u32 pids, lpid;
         int ret;
-        int loop = 3;
+        int loop = DBGP_LOOPS;
 
 retry:
         writel(ctrl | DBGP_GO, &ehci_debug->control);
@@ -197,6 +203,8 @@ retry:
                  */
                 if (ret == -DBGP_TIMEOUT && !dbgp_not_safe)
                         dbgp_not_safe = 1;
+                if (ret == -DBGP_ERR_BAD && --loop > 0)
+                        goto retry;
                 return ret;
         }
 
@@ -245,12 +253,20 @@ static inline void dbgp_get_data(void *buf, int size)
                 bytes[i] = (hi >> (8*(i - 4))) & 0xff;
 }
 
-static int dbgp_out(u32 addr, const char *bytes, int size)
+static int dbgp_bulk_write(unsigned devnum, unsigned endpoint,
+                         const char *bytes, int size)
 {
+        int ret;
+        u32 addr;
         u32 pids, ctrl;
 
+        if (size > DBGP_MAX_PACKET)
+                return -1;
+
+        addr = DBGP_EPADDR(devnum, endpoint);
+
         pids = readl(&ehci_debug->pids);
-        pids = dbgp_pid_update(pids, USB_PID_OUT);
+        pids = dbgp_pid_write_update(pids, USB_PID_OUT);
 
         ctrl = readl(&ehci_debug->control);
         ctrl = dbgp_len_update(ctrl, size);
@@ -260,34 +276,7 @@ static int dbgp_out(u32 addr, const char *bytes, int size)
         dbgp_set_data(bytes, size);
         writel(addr, &ehci_debug->address);
         writel(pids, &ehci_debug->pids);
-        return dbgp_wait_until_done(ctrl);
-}
-
-static int dbgp_bulk_write(unsigned devnum, unsigned endpoint,
-                         const char *bytes, int size)
-{
-        int ret;
-        int loops = 5;
-        u32 addr;
-        if (size > DBGP_MAX_PACKET)
-                return -1;
-
-        addr = DBGP_EPADDR(devnum, endpoint);
-try_again:
-        if (loops--) {
-                ret = dbgp_out(addr, bytes, size);
-                if (ret == -DBGP_ERR_BAD) {
-                        int try_loops = 3;
-                        do {
-                                /* Emit a dummy packet to re-sync communication
-                                 * with the debug device */
-                                if (dbgp_out(addr, "12345678", 8) >= 0) {
-                                        udelay(2);
-                                        goto try_again;
-                                }
-                        } while (try_loops--);
-                }
-        }
+        ret = dbgp_wait_until_done(ctrl);
 
         return ret;
 }
@@ -304,7 +293,7 @@ static int dbgp_bulk_read(unsigned devnum, unsigned endpoint, void *data,
         addr = DBGP_EPADDR(devnum, endpoint);
 
         pids = readl(&ehci_debug->pids);
-        pids = dbgp_pid_update(pids, USB_PID_IN);
+        pids = dbgp_pid_read_update(pids, USB_PID_IN);
 
         ctrl = readl(&ehci_debug->control);
         ctrl = dbgp_len_update(ctrl, size);
@@ -362,7 +351,6 @@ static int dbgp_control_msg(unsigned devnum, int requesttype,
         return dbgp_bulk_read(devnum, 0, data, size);
 }
 
-
 /* Find a PCI capability */
 static u32 __init find_cap(u32 num, u32 slot, u32 func, int cap)
 {
@@ -613,7 +601,7 @@ err:
 }
 EXPORT_SYMBOL_GPL(dbgp_external_startup);
 
-static int __init ehci_reset_port(int port)
+static int ehci_reset_port(int port)
 {
         u32 portsc;
         u32 delay_time, delay;
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index a18e3c5dd82e..11a3e0fa4331 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -732,6 +732,24 @@ config USB_FILE_STORAGE_TEST
           behavior of USB Mass Storage hosts.  Not needed for
           normal operation.
 
+config USB_MASS_STORAGE
+        tristate "Mass Storage Gadget"
+        depends on BLOCK
+        help
+          The Mass Storage Gadget acts as a USB Mass Storage disk drive.
+          As its storage repository it can use a regular file or a block
+          device (in much the same way as the "loop" device driver),
+          specified as a module parameter or sysfs option.
+
+          This is heavily based on File-backed Storage Gadget and in most
+          cases you will want to use FSG instead.  This gadget is mostly
+          here to test the functionality of the Mass Storage Function
+          which may be used with composite framework.
+
+          Say "y" to link the driver statically, or "m" to build
+          a dynamically linked module called "g_mass_storage".  If unsure,
+          consider File-backed Storage Gadget.
+
 config USB_G_SERIAL
         tristate "Serial Gadget (with CDC ACM and CDC OBEX support)"
         help
@@ -794,6 +812,58 @@ config USB_CDC_COMPOSITE
           Say "y" to link the driver statically, or "m" to build a
           dynamically linked module.
 
+config USB_G_NOKIA
+        tristate "Nokia composite gadget"
+        depends on PHONET
+        help
+          The Nokia composite gadget provides support for acm, obex
+          and phonet in only one composite gadget driver.
+
+          It's only really useful for N900 hardware. If you're building
+          a kernel for N900, say Y or M here. If unsure, say N.
+
+config USB_G_MULTI
+        tristate "Multifunction Composite Gadget (EXPERIMENTAL)"
+        depends on BLOCK && NET
+        help
+          The Multifunction Composite Gadget provides Ethernet (RNDIS
+          and/or CDC Ethernet), mass storage and ACM serial link
+          interfaces.
+
+          You will be asked to choose which of the two configurations is
+          to be available in the gadget.  At least one configuration must
+          be chosen to make the gadget usable.  Selecting more than one
+          configuration will prevent Windows from automatically detecting
+          the gadget as a composite gadget, so an INF file will be needed to
+          use the gadget.
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module called "g_multi".
+
+config USB_G_MULTI_RNDIS
+        bool "RNDIS + CDC Serial + Storage configuration"
+        depends on USB_G_MULTI
+        default y
+        help
+          This option enables a configuration with RNDIS, CDC Serial and
+          Mass Storage functions available in the Multifunction Composite
+          Gadget.  This is the configuration dedicated for Windows since RNDIS
+          is Microsoft's protocol.
+
+          If unsure, say "y".
+
+config USB_G_MULTI_CDC
+        bool "CDC Ethernet + CDC Serial + Storage configuration"
+        depends on USB_G_MULTI
+        default n
+        help
+          This option enables a configuration with CDC Ethernet (ECM), CDC
+          Serial and Mass Storage functions available in the Multifunction
+          Composite Gadget.
+
+          If unsure, say "y".
+
+
 # put drivers that need isochronous transfer support (for audio
 # or video class gadget drivers), or specific hardware, here.
 
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 9d7b87c52e9f..43b51da8d727 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -39,16 +39,22 @@ g_serial-objs			:= serial.o
 g_midi-objs                     := gmidi.o
 gadgetfs-objs                   := inode.o
 g_file_storage-objs             := file_storage.o
+g_mass_storage-objs             := mass_storage.o
 g_printer-objs                  := printer.o
 g_cdc-objs                      := cdc2.o
+g_multi-objs                    := multi.o
+g_nokia-objs                    := nokia.o
 
 obj-$(CONFIG_USB_ZERO)          += g_zero.o
 obj-$(CONFIG_USB_AUDIO)         += g_audio.o
 obj-$(CONFIG_USB_ETH)           += g_ether.o
 obj-$(CONFIG_USB_GADGETFS)      += gadgetfs.o
 obj-$(CONFIG_USB_FILE_STORAGE)  += g_file_storage.o
+obj-$(CONFIG_USB_MASS_STORAGE)  += g_mass_storage.o
 obj-$(CONFIG_USB_G_SERIAL)      += g_serial.o
 obj-$(CONFIG_USB_G_PRINTER)     += g_printer.o
 obj-$(CONFIG_USB_MIDI_GADGET)   += g_midi.o
 obj-$(CONFIG_USB_CDC_COMPOSITE) += g_cdc.o
+obj-$(CONFIG_USB_G_MULTI)       += g_multi.o
+obj-$(CONFIG_USB_G_NOKIA)       += g_nokia.o
 
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 66450a1abc22..df1bae9b048e 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -892,7 +892,7 @@ static void pullup(struct at91_udc *udc, int is_on)
 
                         txvc |= AT91_UDP_TXVC_PUON;
                         at91_udp_write(udc, AT91_UDP_TXVC, txvc);
-                } else if (cpu_is_at91sam9261()) {
+                } else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
                         u32     usbpucr;
 
                         usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR);
@@ -910,7 +910,7 @@ static void pullup(struct at91_udc *udc, int is_on)
 
                         txvc &= ~AT91_UDP_TXVC_PUON;
                         at91_udp_write(udc, AT91_UDP_TXVC, txvc);
-                } else if (cpu_is_at91sam9261()) {
+                } else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
                         u32     usbpucr;
 
                         usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR);
@@ -1370,6 +1370,12 @@ static irqreturn_t at91_udc_irq (int irq, void *_udc)
 {
         struct at91_udc         *udc = _udc;
         u32                     rescans = 5;
+        int                     disable_clock = 0;
+
+        if (!udc->clocked) {
+                clk_on(udc);
+                disable_clock = 1;
+        }
 
         while (rescans--) {
                 u32 status;
@@ -1458,6 +1464,9 @@ static irqreturn_t at91_udc_irq (int irq, void *_udc)
                 }
         }
 
+        if (disable_clock)
+                clk_off(udc);
+
         return IRQ_HANDLED;
 }
 
@@ -1656,9 +1665,7 @@ static int __init at91udc_probe(struct platform_device *pdev)
         if (!res)
                 return -ENXIO;
 
-        if (!request_mem_region(res->start,
-                        res->end - res->start + 1,
-                        driver_name)) {
+        if (!request_mem_region(res->start, resource_size(res), driver_name)) {
                 DBG("someone's using UDC memory\n");
                 return -EBUSY;
         }
@@ -1692,14 +1699,14 @@ static int __init at91udc_probe(struct platform_device *pdev)
                 udc->ep[3].maxpacket = 64;
                 udc->ep[4].maxpacket = 512;
                 udc->ep[5].maxpacket = 512;
-        } else if (cpu_is_at91sam9261()) {
+        } else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
                 udc->ep[3].maxpacket = 64;
         } else if (cpu_is_at91sam9263()) {
                 udc->ep[0].maxpacket = 64;
                 udc->ep[3].maxpacket = 64;
         }
 
-        udc->udp_baseaddr = ioremap(res->start, res->end - res->start + 1);
+        udc->udp_baseaddr = ioremap(res->start, resource_size(res));
         if (!udc->udp_baseaddr) {
                 retval = -ENOMEM;
                 goto fail0a;
@@ -1781,7 +1788,7 @@ fail0a:
         if (cpu_is_at91rm9200())
                 gpio_free(udc->board.pullup_pin);
 fail0:
-        release_mem_region(res->start, res->end - res->start + 1);
+        release_mem_region(res->start, resource_size(res));
         DBG("%s probe failed, %d\n", driver_name, retval);
         return retval;
 }
@@ -1813,7 +1820,7 @@ static int __exit at91udc_remove(struct platform_device *pdev)
                 gpio_free(udc->board.pullup_pin);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(res->start, res->end - res->start + 1);
+        release_mem_region(res->start, resource_size(res));
 
         clk_put(udc->iclk);
         clk_put(udc->fclk);
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index 4e970cf0e29a..75a256f3d45b 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -12,6 +12,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <linux/list.h>
@@ -320,7 +321,7 @@ static inline void usba_cleanup_debugfs(struct usba_udc *udc)
 static int vbus_is_present(struct usba_udc *udc)
 {
         if (gpio_is_valid(udc->vbus_pin))
-                return gpio_get_value(udc->vbus_pin);
+                return gpio_get_value(udc->vbus_pin) ^ udc->vbus_pin_inverted;
 
         /* No Vbus detection: Assume always present */
         return 1;
@@ -1763,7 +1764,7 @@ static irqreturn_t usba_vbus_irq(int irq, void *devid)
         if (!udc->driver)
                 goto out;
 
-        vbus = gpio_get_value(udc->vbus_pin);
+        vbus = vbus_is_present(udc);
         if (vbus != udc->vbus_prev) {
                 if (vbus) {
                         toggle_bias(1);
@@ -1914,14 +1915,14 @@ static int __init usba_udc_probe(struct platform_device *pdev)
         udc->vbus_pin = -ENODEV;
 
         ret = -ENOMEM;
-        udc->regs = ioremap(regs->start, regs->end - regs->start + 1);
+        udc->regs = ioremap(regs->start, resource_size(regs));
         if (!udc->regs) {
                 dev_err(&pdev->dev, "Unable to map I/O memory, aborting.\n");
                 goto err_map_regs;
         }
         dev_info(&pdev->dev, "MMIO registers at 0x%08lx mapped at %p\n",
                  (unsigned long)regs->start, udc->regs);
-        udc->fifo = ioremap(fifo->start, fifo->end - fifo->start + 1);
+        udc->fifo = ioremap(fifo->start, resource_size(fifo));
         if (!udc->fifo) {
                 dev_err(&pdev->dev, "Unable to map FIFO, aborting.\n");
                 goto err_map_fifo;
@@ -2000,6 +2001,7 @@ static int __init usba_udc_probe(struct platform_device *pdev)
         if (gpio_is_valid(pdata->vbus_pin)) {
                 if (!gpio_request(pdata->vbus_pin, "atmel_usba_udc")) {
                         udc->vbus_pin = pdata->vbus_pin;
+                        udc->vbus_pin_inverted = pdata->vbus_pin_inverted;
 
                         ret = request_irq(gpio_to_irq(udc->vbus_pin),
                                         usba_vbus_irq, 0,
diff --git a/drivers/usb/gadget/atmel_usba_udc.h b/drivers/usb/gadget/atmel_usba_udc.h
index f7baea307f0d..88a2e07a11a8 100644
--- a/drivers/usb/gadget/atmel_usba_udc.h
+++ b/drivers/usb/gadget/atmel_usba_udc.h
@@ -323,6 +323,7 @@ struct usba_udc {
         struct platform_device *pdev;
         int irq;
         int vbus_pin;
+        int vbus_pin_inverted;
         struct clk *pclk;
         struct clk *hclk;
 
diff --git a/drivers/usb/gadget/audio.c b/drivers/usb/gadget/audio.c
index a3a0f4a27ef0..a62af7b59094 100644
--- a/drivers/usb/gadget/audio.c
+++ b/drivers/usb/gadget/audio.c
@@ -89,120 +89,6 @@ static const struct usb_descriptor_header *otg_desc[] = {
 
 /*-------------------------------------------------------------------------*/
 
-/**
- * Handle USB audio endpoint set/get command in setup class request
- */
-
-static int audio_set_endpoint_req(struct usb_configuration *c,
-                const struct usb_ctrlrequest *ctrl)
-{
-        struct usb_composite_dev *cdev = c->cdev;
-        int                     value = -EOPNOTSUPP;
-        u16                     ep = le16_to_cpu(ctrl->wIndex);
-        u16                     len = le16_to_cpu(ctrl->wLength);
-        u16                     w_value = le16_to_cpu(ctrl->wValue);
-
-        DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
-                        ctrl->bRequest, w_value, len, ep);
-
-        switch (ctrl->bRequest) {
-        case UAC_SET_CUR:
-                value = 0;
-                break;
-
-        case UAC_SET_MIN:
-                break;
-
-        case UAC_SET_MAX:
-                break;
-
-        case UAC_SET_RES:
-                break;
-
-        case UAC_SET_MEM:
-                break;
-
-        default:
-                break;
-        }
-
-        return value;
-}
-
-static int audio_get_endpoint_req(struct usb_configuration *c,
-                const struct usb_ctrlrequest *ctrl)
-{
-        struct usb_composite_dev *cdev = c->cdev;
-        int value = -EOPNOTSUPP;
-        u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
-        u16 len = le16_to_cpu(ctrl->wLength);
-        u16 w_value = le16_to_cpu(ctrl->wValue);
-
-        DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
-                        ctrl->bRequest, w_value, len, ep);
-
-        switch (ctrl->bRequest) {
-        case UAC_GET_CUR:
-        case UAC_GET_MIN:
-        case UAC_GET_MAX:
-        case UAC_GET_RES:
-                value = 3;
-                break;
-        case UAC_GET_MEM:
-                break;
-        default:
-                break;
-        }
-
-        return value;
-}
-
-static int
-audio_setup(struct usb_configuration *c, const struct usb_ctrlrequest *ctrl)
-{
-        struct usb_composite_dev *cdev = c->cdev;
-        struct usb_request *req = cdev->req;
-        int value = -EOPNOTSUPP;
-        u16 w_index = le16_to_cpu(ctrl->wIndex);
-        u16 w_value = le16_to_cpu(ctrl->wValue);
-        u16 w_length = le16_to_cpu(ctrl->wLength);
-
-        /* composite driver infrastructure handles everything except
-         * Audio class messages; interface activation uses set_alt().
-         */
-        switch (ctrl->bRequestType) {
-        case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
-                value = audio_set_endpoint_req(c, ctrl);
-                break;
-
-        case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
-                value = audio_get_endpoint_req(c, ctrl);
-                break;
-
-        default:
-                ERROR(cdev, "Invalid control req%02x.%02x v%04x i%04x l%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        w_value, w_index, w_length);
-        }
-
-        /* respond with data transfer or status phase? */
-        if (value >= 0) {
-                DBG(cdev, "Audio req%02x.%02x v%04x i%04x l%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        w_value, w_index, w_length);
-                req->zero = 0;
-                req->length = value;
-                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
-                if (value < 0)
-                        ERROR(cdev, "Audio response on err %d\n", value);
-        }
-
-        /* device either stalls (value < 0) or reports success */
-        return value;
-}
-
-/*-------------------------------------------------------------------------*/
-
 static int __init audio_do_config(struct usb_configuration *c)
 {
         /* FIXME alloc iConfiguration string, set it in c->strings */
@@ -220,7 +106,6 @@ static int __init audio_do_config(struct usb_configuration *c)
 static struct usb_configuration audio_config_driver = {
         .label                  = DRIVER_DESC,
         .bind                   = audio_do_config,
-        .setup                  = audio_setup,
         .bConfigurationValue    = 1,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
@@ -273,6 +158,7 @@ fail:
 
 static int __exit audio_unbind(struct usb_composite_dev *cdev)
 {
+        gaudio_cleanup();
         return 0;
 }
 
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c
index c7cb87a6fee2..699695128e33 100644
--- a/drivers/usb/gadget/ci13xxx_udc.c
+++ b/drivers/usb/gadget/ci13xxx_udc.c
@@ -62,6 +62,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index d05397ec8a18..09289bb1e20f 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -373,6 +373,8 @@ static void reset_config(struct usb_composite_dev *cdev)
         list_for_each_entry(f, &cdev->config->functions, list) {
                 if (f->disable)
                         f->disable(f);
+
+                bitmap_zero(f->endpoints, 32);
         }
         cdev->config = NULL;
 }
@@ -418,10 +420,35 @@ static int set_config(struct usb_composite_dev *cdev,
         /* Initialize all interfaces by setting them to altsetting zero. */
         for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
                 struct usb_function     *f = c->interface[tmp];
+                struct usb_descriptor_header **descriptors;
 
                 if (!f)
                         break;
 
+                /*
+                 * Record which endpoints are used by the function. This is used
+                 * to dispatch control requests targeted at that endpoint to the
+                 * function's setup callback instead of the current
+                 * configuration's setup callback.
+                 */
+                if (gadget->speed == USB_SPEED_HIGH)
+                        descriptors = f->hs_descriptors;
+                else
+                        descriptors = f->descriptors;
+
+                for (; *descriptors; ++descriptors) {
+                        struct usb_endpoint_descriptor *ep;
+                        int addr;
+
+                        if ((*descriptors)->bDescriptorType != USB_DT_ENDPOINT)
+                                continue;
+
+                        ep = (struct usb_endpoint_descriptor *)*descriptors;
+                        addr = ((ep->bEndpointAddress & 0x80) >> 3)
+                             |  (ep->bEndpointAddress & 0x0f);
+                        set_bit(addr, f->endpoints);
+                }
+
                 result = f->set_alt(f, tmp, 0);
                 if (result < 0) {
                         DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
@@ -688,6 +715,7 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
         u16                             w_value = le16_to_cpu(ctrl->wValue);
         u16                             w_length = le16_to_cpu(ctrl->wLength);
         struct usb_function             *f = NULL;
+        u8                              endp;
 
         /* partial re-init of the response message; the function or the
          * gadget might need to intercept e.g. a control-OUT completion
@@ -800,23 +828,33 @@ unknown:
                         ctrl->bRequestType, ctrl->bRequest,
                         w_value, w_index, w_length);
 
-                /* functions always handle their interfaces ... punt other
-                 * recipients (endpoint, other, WUSB, ...) to the current
+                /* functions always handle their interfaces and endpoints...
+                 * punt other recipients (other, WUSB, ...) to the current
                  * configuration code.
                  *
                  * REVISIT it could make sense to let the composite device
                  * take such requests too, if that's ever needed:  to work
                  * in config 0, etc.
                  */
-                if ((ctrl->bRequestType & USB_RECIP_MASK)
-                                == USB_RECIP_INTERFACE) {
+                switch (ctrl->bRequestType & USB_RECIP_MASK) {
+                case USB_RECIP_INTERFACE:
                         f = cdev->config->interface[intf];
-                        if (f && f->setup)
-                                value = f->setup(f, ctrl);
-                        else
+                        break;
+
+                case USB_RECIP_ENDPOINT:
+                        endp = ((w_index & 0x80) >> 3) | (w_index & 0x0f);
+                        list_for_each_entry(f, &cdev->config->functions, list) {
+                                if (test_bit(endp, f->endpoints))
+                                        break;
+                        }
+                        if (&f->list == &cdev->config->functions)
                                 f = NULL;
+                        break;
                 }
-                if (value < 0 && !f) {
+
+                if (f && f->setup)
+                        value = f->setup(f, ctrl);
+                else {
                         struct usb_configuration        *c;
 
                         c = cdev->config;
@@ -1054,7 +1092,8 @@ static struct usb_gadget_driver composite_driver = {
         .speed          = USB_SPEED_HIGH,
 
         .bind           = composite_bind,
-        .unbind         = __exit_p(composite_unbind),
+        /* .unbind              = __exit_p(composite_unbind), */
+        .unbind         = composite_unbind,
 
         .setup          = composite_setup,
         .disconnect     = composite_disconnect,
@@ -1103,7 +1142,7 @@ int __init usb_composite_register(struct usb_composite_driver *driver)
  * This function is used to unregister drivers using the composite
  * driver framework.
  */
-void __exit usb_composite_unregister(struct usb_composite_driver *driver)
+void /* __exit */ usb_composite_unregister(struct usb_composite_driver *driver)
 {
         if (composite != driver)
                 return;
diff --git a/drivers/usb/gadget/config.c b/drivers/usb/gadget/config.c
index e1191b9a316a..47e8e722682c 100644
--- a/drivers/usb/gadget/config.c
+++ b/drivers/usb/gadget/config.c
@@ -19,6 +19,7 @@
  */
 
 #include <linux/errno.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/string.h>
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index cd0914ec898e..3568de210f79 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -265,16 +265,24 @@ struct usb_ep * __init usb_ep_autoconfig (
                                 return ep;
                 }
 
-        } else if (gadget_is_sh (gadget) && USB_ENDPOINT_XFER_INT == type) {
-                /* single buffering is enough; maybe 8 byte fifo is too */
-                ep = find_ep (gadget, "ep3in-bulk");
-                if (ep && ep_matches (gadget, ep, desc))
-                        return ep;
-
-        } else if (gadget_is_mq11xx (gadget) && USB_ENDPOINT_XFER_INT == type) {
-                ep = find_ep (gadget, "ep1-bulk");
+#ifdef CONFIG_BLACKFIN
+        } else if (gadget_is_musbhdrc(gadget)) {
+                if ((USB_ENDPOINT_XFER_BULK == type) ||
+                    (USB_ENDPOINT_XFER_ISOC == type)) {
+                        if (USB_DIR_IN & desc->bEndpointAddress)
+                                ep = find_ep (gadget, "ep5in");
+                        else
+                                ep = find_ep (gadget, "ep6out");
+                } else if (USB_ENDPOINT_XFER_INT == type) {
+                        if (USB_DIR_IN & desc->bEndpointAddress)
+                                ep = find_ep(gadget, "ep1in");
+                        else
+                                ep = find_ep(gadget, "ep2out");
+                } else
+                        ep = NULL;
                 if (ep && ep_matches (gadget, ep, desc))
                         return ep;
+#endif
         }
 
         /* Second, look at endpoints until an unclaimed one looks usable */
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 167cb2a8ecef..400f80372d93 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -25,6 +25,14 @@
 #include <linux/kernel.h>
 #include <linux/utsname.h>
 
+
+#if defined USB_ETH_RNDIS
+#  undef USB_ETH_RNDIS
+#endif
+#ifdef CONFIG_USB_ETH_RNDIS
+#  define USB_ETH_RNDIS y
+#endif
+
 #include "u_ether.h"
 
 
@@ -66,7 +74,7 @@
 #define DRIVER_DESC             "Ethernet Gadget"
 #define DRIVER_VERSION          "Memorial Day 2008"
 
-#ifdef CONFIG_USB_ETH_RNDIS
+#ifdef USB_ETH_RNDIS
 #define PREFIX                  "RNDIS/"
 #else
 #define PREFIX                  ""
@@ -87,7 +95,7 @@
 
 static inline bool has_rndis(void)
 {
-#ifdef  CONFIG_USB_ETH_RNDIS
+#ifdef  USB_ETH_RNDIS
         return true;
 #else
         return false;
@@ -110,7 +118,7 @@ static inline bool has_rndis(void)
 
 #include "f_ecm.c"
 #include "f_subset.c"
-#ifdef  CONFIG_USB_ETH_RNDIS
+#ifdef  USB_ETH_RNDIS
 #include "f_rndis.c"
 #include "rndis.c"
 #endif
diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
index 7953948bfe4a..400e1ebe6976 100644
--- a/drivers/usb/gadget/f_acm.c
+++ b/drivers/usb/gadget/f_acm.c
@@ -4,6 +4,8 @@
  * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
  * Copyright (C) 2008 by David Brownell
  * Copyright (C) 2008 by Nokia Corporation
+ * Copyright (C) 2009 by Samsung Electronics
+ * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
  *
  * This software is distributed under the terms of the GNU General
  * Public License ("GPL") as published by the Free Software Foundation,
@@ -12,6 +14,7 @@
 
 /* #define VERBOSE_DEBUG */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 
@@ -99,6 +102,20 @@ static inline struct f_acm *port_to_acm(struct gserial *p)
 
 /* interface and class descriptors: */
 
+static struct usb_interface_assoc_descriptor
+acm_iad_descriptor = {
+        .bLength =              sizeof acm_iad_descriptor,
+        .bDescriptorType =      USB_DT_INTERFACE_ASSOCIATION,
+
+        /* .bFirstInterface =   DYNAMIC, */
+        .bInterfaceCount =      2,      // control + data
+        .bFunctionClass =       USB_CLASS_COMM,
+        .bFunctionSubClass =    USB_CDC_SUBCLASS_ACM,
+        .bFunctionProtocol =    USB_CDC_PROTO_NONE,
+        /* .iFunction =         DYNAMIC */
+};
+
+
 static struct usb_interface_descriptor acm_control_interface_desc __initdata = {
         .bLength =              USB_DT_INTERFACE_SIZE,
         .bDescriptorType =      USB_DT_INTERFACE,
@@ -178,6 +195,7 @@ static struct usb_endpoint_descriptor acm_fs_out_desc __initdata = {
 };
 
 static struct usb_descriptor_header *acm_fs_function[] __initdata = {
+        (struct usb_descriptor_header *) &acm_iad_descriptor,
         (struct usb_descriptor_header *) &acm_control_interface_desc,
         (struct usb_descriptor_header *) &acm_header_desc,
         (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
@@ -216,6 +234,7 @@ static struct usb_endpoint_descriptor acm_hs_out_desc __initdata = {
 };
 
 static struct usb_descriptor_header *acm_hs_function[] __initdata = {
+        (struct usb_descriptor_header *) &acm_iad_descriptor,
         (struct usb_descriptor_header *) &acm_control_interface_desc,
         (struct usb_descriptor_header *) &acm_header_desc,
         (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
@@ -232,11 +251,13 @@ static struct usb_descriptor_header *acm_hs_function[] __initdata = {
 
 #define ACM_CTRL_IDX    0
 #define ACM_DATA_IDX    1
+#define ACM_IAD_IDX     2
 
 /* static strings, in UTF-8 */
 static struct usb_string acm_string_defs[] = {
         [ACM_CTRL_IDX].s = "CDC Abstract Control Model (ACM)",
         [ACM_DATA_IDX].s = "CDC ACM Data",
+        [ACM_IAD_IDX ].s = "CDC Serial",
         {  /* ZEROES END LIST */ },
 };
 
@@ -432,7 +453,7 @@ static void acm_disable(struct usb_function *f)
  * @length: size of data
  * Context: irqs blocked, acm->lock held, acm_notify_req non-null
  *
- * Returns zero on sucess or a negative errno.
+ * Returns zero on success or a negative errno.
  *
  * See section 6.3.5 of the CDC 1.1 specification for information
  * about the only notification we issue:  SerialState change.
@@ -563,6 +584,7 @@ acm_bind(struct usb_configuration *c, struct usb_function *f)
         if (status < 0)
                 goto fail;
         acm->ctrl_id = status;
+        acm_iad_descriptor.bFirstInterface = status;
 
         acm_control_interface_desc.bInterfaceNumber = status;
         acm_union_desc .bMasterInterface0 = status;
@@ -681,14 +703,6 @@ acm_unbind(struct usb_configuration *c, struct usb_function *f)
 /* Some controllers can't support CDC ACM ... */
 static inline bool can_support_cdc(struct usb_configuration *c)
 {
-        /* SH3 doesn't support multiple interfaces */
-        if (gadget_is_sh(c->cdev->gadget))
-                return false;
-
-        /* sa1100 doesn't have a third interrupt endpoint */
-        if (gadget_is_sa1100(c->cdev->gadget))
-                return false;
-
         /* everything else is *probably* fine ... */
         return true;
 }
@@ -732,6 +746,13 @@ int __init acm_bind_config(struct usb_configuration *c, u8 port_num)
                 acm_string_defs[ACM_DATA_IDX].id = status;
 
                 acm_data_interface_desc.iInterface = status;
+
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                acm_string_defs[ACM_IAD_IDX].id = status;
+
+                acm_iad_descriptor.iFunction = status;
         }
 
         /* allocate and initialize one new instance */
diff --git a/drivers/usb/gadget/f_audio.c b/drivers/usb/gadget/f_audio.c
index 98e9bb977291..43bf44514c41 100644
--- a/drivers/usb/gadget/f_audio.c
+++ b/drivers/usb/gadget/f_audio.c
@@ -9,6 +9,7 @@
  * Licensed under the GPL-2 or later.
  */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <asm/atomic.h>
@@ -56,13 +57,16 @@ static struct usb_interface_descriptor ac_interface_desc __initdata = {
 DECLARE_UAC_AC_HEADER_DESCRIPTOR(2);
 
 #define UAC_DT_AC_HEADER_LENGTH UAC_DT_AC_HEADER_SIZE(F_AUDIO_NUM_INTERFACES)
+/* 1 input terminal, 1 output terminal and 1 feature unit */
+#define UAC_DT_TOTAL_LENGTH (UAC_DT_AC_HEADER_LENGTH + UAC_DT_INPUT_TERMINAL_SIZE \
+        + UAC_DT_OUTPUT_TERMINAL_SIZE + UAC_DT_FEATURE_UNIT_SIZE(0))
 /* B.3.2  Class-Specific AC Interface Descriptor */
-static struct uac_ac_header_descriptor_2 ac_header_desc = {
+static struct uac_ac_header_descriptor_v1_2 ac_header_desc = {
         .bLength =              UAC_DT_AC_HEADER_LENGTH,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubtype =   UAC_HEADER,
         .bcdADC =               __constant_cpu_to_le16(0x0100),
-        .wTotalLength =         __constant_cpu_to_le16(UAC_DT_AC_HEADER_LENGTH),
+        .wTotalLength =         __constant_cpu_to_le16(UAC_DT_TOTAL_LENGTH),
         .bInCollection =        F_AUDIO_NUM_INTERFACES,
         .baInterfaceNr = {
                 [0] =           F_AUDIO_AC_INTERFACE,
@@ -121,7 +125,7 @@ static struct usb_audio_control_selector feature_unit = {
 };
 
 #define OUTPUT_TERMINAL_ID      3
-static struct uac_output_terminal_descriptor output_terminal_desc = {
+static struct uac_output_terminal_descriptor_v1 output_terminal_desc = {
         .bLength                = UAC_DT_OUTPUT_TERMINAL_SIZE,
         .bDescriptorType        = USB_DT_CS_INTERFACE,
         .bDescriptorSubtype     = UAC_OUTPUT_TERMINAL,
@@ -151,7 +155,7 @@ static struct usb_interface_descriptor as_interface_alt_1_desc = {
 };
 
 /* B.4.2  Class-Specific AS Interface Descriptor */
-static struct uac_as_header_descriptor as_header_desc = {
+static struct uac_as_header_descriptor_v1 as_header_desc = {
         .bLength =              UAC_DT_AS_HEADER_SIZE,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubtype =   UAC_AS_GENERAL,
@@ -252,12 +256,12 @@ static struct f_audio_buf *f_audio_buffer_alloc(int buf_size)
 
         copy_buf = kzalloc(sizeof *copy_buf, GFP_ATOMIC);
         if (!copy_buf)
-                return (struct f_audio_buf *)-ENOMEM;
+                return ERR_PTR(-ENOMEM);
 
         copy_buf->buf = kzalloc(buf_size, GFP_ATOMIC);
         if (!copy_buf->buf) {
                 kfree(copy_buf);
-                return (struct f_audio_buf *)-ENOMEM;
+                return ERR_PTR(-ENOMEM);
         }
 
         return copy_buf;
@@ -332,7 +336,7 @@ static int f_audio_out_ep_complete(struct usb_ep *ep, struct usb_request *req)
                 list_add_tail(&copy_buf->list, &audio->play_queue);
                 schedule_work(&audio->playback_work);
                 copy_buf = f_audio_buffer_alloc(audio_buf_size);
-                if (copy_buf < 0)
+                if (IS_ERR(copy_buf))
                         return -ENOMEM;
         }
 
@@ -445,6 +449,70 @@ static int audio_get_intf_req(struct usb_function *f,
         return len;
 }
 
+static int audio_set_endpoint_req(struct usb_function *f,
+                const struct usb_ctrlrequest *ctrl)
+{
+        struct usb_composite_dev *cdev = f->config->cdev;
+        int                     value = -EOPNOTSUPP;
+        u16                     ep = le16_to_cpu(ctrl->wIndex);
+        u16                     len = le16_to_cpu(ctrl->wLength);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+
+        DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
+                        ctrl->bRequest, w_value, len, ep);
+
+        switch (ctrl->bRequest) {
+        case UAC_SET_CUR:
+                value = 0;
+                break;
+
+        case UAC_SET_MIN:
+                break;
+
+        case UAC_SET_MAX:
+                break;
+
+        case UAC_SET_RES:
+                break;
+
+        case UAC_SET_MEM:
+                break;
+
+        default:
+                break;
+        }
+
+        return value;
+}
+
+static int audio_get_endpoint_req(struct usb_function *f,
+                const struct usb_ctrlrequest *ctrl)
+{
+        struct usb_composite_dev *cdev = f->config->cdev;
+        int value = -EOPNOTSUPP;
+        u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
+        u16 len = le16_to_cpu(ctrl->wLength);
+        u16 w_value = le16_to_cpu(ctrl->wValue);
+
+        DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
+                        ctrl->bRequest, w_value, len, ep);
+
+        switch (ctrl->bRequest) {
+        case UAC_GET_CUR:
+        case UAC_GET_MIN:
+        case UAC_GET_MAX:
+        case UAC_GET_RES:
+                value = 3;
+                break;
+        case UAC_GET_MEM:
+                break;
+        default:
+                break;
+        }
+
+        return value;
+}
+
 static int
 f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 {
@@ -455,8 +523,8 @@ f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
         u16                     w_value = le16_to_cpu(ctrl->wValue);
         u16                     w_length = le16_to_cpu(ctrl->wLength);
 
-        /* composite driver infrastructure handles everything except
-         * Audio class messages; interface activation uses set_alt().
+        /* composite driver infrastructure handles everything; interface
+         * activation uses set_alt().
          */
         switch (ctrl->bRequestType) {
         case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
@@ -467,6 +535,14 @@ f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
                 value = audio_get_intf_req(f, ctrl);
                 break;
 
+        case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
+                value = audio_set_endpoint_req(f, ctrl);
+                break;
+
+        case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
+                value = audio_get_endpoint_req(f, ctrl);
+                break;
+
         default:
                 ERROR(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
                         ctrl->bRequestType, ctrl->bRequest,
@@ -504,6 +580,8 @@ static int f_audio_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         usb_ep_enable(out_ep, audio->out_desc);
                         out_ep->driver_data = audio;
                         audio->copy_buf = f_audio_buffer_alloc(audio_buf_size);
+                        if (IS_ERR(audio->copy_buf))
+                                return -ENOMEM;
 
                         /*
                          * allocate a bunch of read buffers
@@ -715,7 +793,7 @@ int __init audio_bind_config(struct usb_configuration *c)
         return status;
 
 add_fail:
-        gaudio_cleanup(&audio->card);
+        gaudio_cleanup();
 setup_fail:
         kfree(audio);
         return status;
diff --git a/drivers/usb/gadget/f_ecm.c b/drivers/usb/gadget/f_ecm.c
index ecf5bdd0ae06..4e595324c614 100644
--- a/drivers/usb/gadget/f_ecm.c
+++ b/drivers/usb/gadget/f_ecm.c
@@ -21,6 +21,7 @@
 
 /* #define VERBOSE_DEBUG */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <linux/etherdevice.h>
@@ -497,12 +498,9 @@ static int ecm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                         struct net_device       *net;
 
                         /* Enable zlps by default for ECM conformance;
-                         * override for musb_hdrc (avoids txdma ovhead)
-                         * and sa1100 (can't).
+                         * override for musb_hdrc (avoids txdma ovhead).
                          */
-                        ecm->port.is_zlp_ok = !(
-                                   gadget_is_sa1100(cdev->gadget)
-                                || gadget_is_musbhdrc(cdev->gadget)
+                        ecm->port.is_zlp_ok = !(gadget_is_musbhdrc(cdev->gadget)
                                 );
                         ecm->port.cdc_filter = DEFAULT_FILTER;
                         DBG(cdev, "activate ecm\n");
diff --git a/drivers/usb/gadget/f_eem.c b/drivers/usb/gadget/f_eem.c
index 0a577d5694fd..38226e9a371d 100644
--- a/drivers/usb/gadget/f_eem.c
+++ b/drivers/usb/gadget/f_eem.c
@@ -24,6 +24,7 @@
 #include <linux/device.h>
 #include <linux/etherdevice.h>
 #include <linux/crc32.h>
+#include <linux/slab.h>
 
 #include "u_ether.h"
 
@@ -358,7 +359,7 @@ done:
          * b15:         bmType (0 == data)
          */
         len = skb->len;
-        put_unaligned_le16((len & 0x3FFF) | BIT(14), skb_push(skb, 2));
+        put_unaligned_le16(len & 0x3FFF, skb_push(skb, 2));
 
         /* add a zero-length EEM packet, if needed */
         if (padlen)
@@ -464,7 +465,6 @@ static int eem_unwrap(struct gether *port,
                         }
 
                         /* validate CRC */
-                        crc = get_unaligned_le32(skb->data + len - ETH_FCS_LEN);
                         if (header & BIT(14)) {
                                 crc = get_unaligned_le32(skb->data + len
                                                         - ETH_FCS_LEN);
diff --git a/drivers/usb/gadget/f_loopback.c b/drivers/usb/gadget/f_loopback.c
index 6cb29d3df575..e91d1b16d9be 100644
--- a/drivers/usb/gadget/f_loopback.c
+++ b/drivers/usb/gadget/f_loopback.c
@@ -21,6 +21,7 @@
 
 /* #define VERBOSE_DEBUG */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
new file mode 100644
index 000000000000..f4911c09022e
--- /dev/null
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -0,0 +1,3098 @@
+/*
+ * f_mass_storage.c -- Mass Storage USB Composite Function
+ *
+ * Copyright (C) 2003-2008 Alan Stern
+ * Copyright (C) 2009 Samsung Electronics
+ *                    Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The names of the above-listed copyright holders may not be used
+ *    to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * ALTERNATIVELY, this software may be 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+/*
+ * The Mass Storage Function acts as a USB Mass Storage device,
+ * appearing to the host as a disk drive or as a CD-ROM drive.  In
+ * addition to providing an example of a genuinely useful composite
+ * function for a USB device, it also illustrates a technique of
+ * double-buffering for increased throughput.
+ *
+ * Function supports multiple logical units (LUNs).  Backing storage
+ * for each LUN is provided by a regular file or a block device.
+ * Access for each LUN can be limited to read-only.  Moreover, the
+ * function can indicate that LUN is removable and/or CD-ROM.  (The
+ * later implies read-only access.)
+ *
+ * MSF is configured by specifying a fsg_config structure.  It has the
+ * following fields:
+ *
+ *      nluns           Number of LUNs function have (anywhere from 1
+ *                              to FSG_MAX_LUNS which is 8).
+ *      luns            An array of LUN configuration values.  This
+ *                              should be filled for each LUN that
+ *                              function will include (ie. for "nluns"
+ *                              LUNs).  Each element of the array has
+ *                              the following fields:
+ *      ->filename      The path to the backing file for the LUN.
+ *                              Required if LUN is not marked as
+ *                              removable.
+ *      ->ro            Flag specifying access to the LUN shall be
+ *                              read-only.  This is implied if CD-ROM
+ *                              emulation is enabled as well as when
+ *                              it was impossible to open "filename"
+ *                              in R/W mode.
+ *      ->removable     Flag specifying that LUN shall be indicated as
+ *                              being removable.
+ *      ->cdrom         Flag specifying that LUN shall be reported as
+ *                              being a CD-ROM.
+ *
+ *      lun_name_format A printf-like format for names of the LUN
+ *                              devices.  This determines how the
+ *                              directory in sysfs will be named.
+ *                              Unless you are using several MSFs in
+ *                              a single gadget (as opposed to single
+ *                              MSF in many configurations) you may
+ *                              leave it as NULL (in which case
+ *                              "lun%d" will be used).  In the format
+ *                              you can use "%d" to index LUNs for
+ *                              MSF's with more than one LUN.  (Beware
+ *                              that there is only one integer given
+ *                              as an argument for the format and
+ *                              specifying invalid format may cause
+ *                              unspecified behaviour.)
+ *      thread_name     Name of the kernel thread process used by the
+ *                              MSF.  You can safely set it to NULL
+ *                              (in which case default "file-storage"
+ *                              will be used).
+ *
+ *      vendor_name
+ *      product_name
+ *      release         Information used as a reply to INQUIRY
+ *                              request.  To use default set to NULL,
+ *                              NULL, 0xffff respectively.  The first
+ *                              field should be 8 and the second 16
+ *                              characters or less.
+ *
+ *      can_stall       Set to permit function to halt bulk endpoints.
+ *                              Disabled on some USB devices known not
+ *                              to work correctly.  You should set it
+ *                              to true.
+ *
+ * If "removable" is not set for a LUN then a backing file must be
+ * specified.  If it is set, then NULL filename means the LUN's medium
+ * is not loaded (an empty string as "filename" in the fsg_config
+ * structure causes error).  The CD-ROM emulation includes a single
+ * data track and no audio tracks; hence there need be only one
+ * backing file per LUN.  Note also that the CD-ROM block length is
+ * set to 512 rather than the more common value 2048.
+ *
+ *
+ * MSF includes support for module parameters.  If gadget using it
+ * decides to use it, the following module parameters will be
+ * available:
+ *
+ *      file=filename[,filename...]
+ *                      Names of the files or block devices used for
+ *                              backing storage.
+ *      ro=b[,b...]     Default false, boolean for read-only access.
+ *      removable=b[,b...]
+ *                      Default true, boolean for removable media.
+ *      cdrom=b[,b...]  Default false, boolean for whether to emulate
+ *                              a CD-ROM drive.
+ *      luns=N          Default N = number of filenames, number of
+ *                              LUNs to support.
+ *      stall           Default determined according to the type of
+ *                              USB device controller (usually true),
+ *                              boolean to permit the driver to halt
+ *                              bulk endpoints.
+ *
+ * The module parameters may be prefixed with some string.  You need
+ * to consult gadget's documentation or source to verify whether it is
+ * using those module parameters and if it does what are the prefixes
+ * (look for FSG_MODULE_PARAMETERS() macro usage, what's inside it is
+ * the prefix).
+ *
+ *
+ * Requirements are modest; only a bulk-in and a bulk-out endpoint are
+ * needed.  The memory requirement amounts to two 16K buffers, size
+ * configurable by a parameter.  Support is included for both
+ * full-speed and high-speed operation.
+ *
+ * Note that the driver is slightly non-portable in that it assumes a
+ * single memory/DMA buffer will be useable for bulk-in, bulk-out, and
+ * interrupt-in endpoints.  With most device controllers this isn't an
+ * issue, but there may be some with hardware restrictions that prevent
+ * a buffer from being used by more than one endpoint.
+ *
+ *
+ * The pathnames of the backing files and the ro settings are
+ * available in the attribute files "file" and "ro" in the lun<n> (or
+ * to be more precise in a directory which name comes from
+ * "lun_name_format" option!) subdirectory of the gadget's sysfs
+ * directory.  If the "removable" option is set, writing to these
+ * files will simulate ejecting/loading the medium (writing an empty
+ * line means eject) and adjusting a write-enable tab.  Changes to the
+ * ro setting are not allowed when the medium is loaded or if CD-ROM
+ * emulation is being used.
+ *
+ *
+ * This function is heavily based on "File-backed Storage Gadget" by
+ * Alan Stern which in turn is heavily based on "Gadget Zero" by David
+ * Brownell.  The driver's SCSI command interface was based on the
+ * "Information technology - Small Computer System Interface - 2"
+ * document from X3T9.2 Project 375D, Revision 10L, 7-SEP-93,
+ * available at <http://www.t10.org/ftp/t10/drafts/s2/s2-r10l.pdf>.
+ * The single exception is opcode 0x23 (READ FORMAT CAPACITIES), which
+ * was based on the "Universal Serial Bus Mass Storage Class UFI
+ * Command Specification" document, Revision 1.0, December 14, 1998,
+ * available at
+ * <http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf>.
+ */
+
+
+/*
+ *                              Driver Design
+ *
+ * The MSF is fairly straightforward.  There is a main kernel
+ * thread that handles most of the work.  Interrupt routines field
+ * callbacks from the controller driver: bulk- and interrupt-request
+ * completion notifications, endpoint-0 events, and disconnect events.
+ * Completion events are passed to the main thread by wakeup calls.  Many
+ * ep0 requests are handled at interrupt time, but SetInterface,
+ * SetConfiguration, and device reset requests are forwarded to the
+ * thread in the form of "exceptions" using SIGUSR1 signals (since they
+ * should interrupt any ongoing file I/O operations).
+ *
+ * The thread's main routine implements the standard command/data/status
+ * parts of a SCSI interaction.  It and its subroutines are full of tests
+ * for pending signals/exceptions -- all this polling is necessary since
+ * the kernel has no setjmp/longjmp equivalents.  (Maybe this is an
+ * indication that the driver really wants to be running in userspace.)
+ * An important point is that so long as the thread is alive it keeps an
+ * open reference to the backing file.  This will prevent unmounting
+ * the backing file's underlying filesystem and could cause problems
+ * during system shutdown, for example.  To prevent such problems, the
+ * thread catches INT, TERM, and KILL signals and converts them into
+ * an EXIT exception.
+ *
+ * In normal operation the main thread is started during the gadget's
+ * fsg_bind() callback and stopped during fsg_unbind().  But it can
+ * also exit when it receives a signal, and there's no point leaving
+ * the gadget running when the thread is dead.  At of this moment, MSF
+ * provides no way to deregister the gadget when thread dies -- maybe
+ * a callback functions is needed.
+ *
+ * To provide maximum throughput, the driver uses a circular pipeline of
+ * buffer heads (struct fsg_buffhd).  In principle the pipeline can be
+ * arbitrarily long; in practice the benefits don't justify having more
+ * than 2 stages (i.e., double buffering).  But it helps to think of the
+ * pipeline as being a long one.  Each buffer head contains a bulk-in and
+ * a bulk-out request pointer (since the buffer can be used for both
+ * output and input -- directions always are given from the host's
+ * point of view) as well as a pointer to the buffer and various state
+ * variables.
+ *
+ * Use of the pipeline follows a simple protocol.  There is a variable
+ * (fsg->next_buffhd_to_fill) that points to the next buffer head to use.
+ * At any time that buffer head may still be in use from an earlier
+ * request, so each buffer head has a state variable indicating whether
+ * it is EMPTY, FULL, or BUSY.  Typical use involves waiting for the
+ * buffer head to be EMPTY, filling the buffer either by file I/O or by
+ * USB I/O (during which the buffer head is BUSY), and marking the buffer
+ * head FULL when the I/O is complete.  Then the buffer will be emptied
+ * (again possibly by USB I/O, during which it is marked BUSY) and
+ * finally marked EMPTY again (possibly by a completion routine).
+ *
+ * A module parameter tells the driver to avoid stalling the bulk
+ * endpoints wherever the transport specification allows.  This is
+ * necessary for some UDCs like the SuperH, which cannot reliably clear a
+ * halt on a bulk endpoint.  However, under certain circumstances the
+ * Bulk-only specification requires a stall.  In such cases the driver
+ * will halt the endpoint and set a flag indicating that it should clear
+ * the halt in software during the next device reset.  Hopefully this
+ * will permit everything to work correctly.  Furthermore, although the
+ * specification allows the bulk-out endpoint to halt when the host sends
+ * too much data, implementing this would cause an unavoidable race.
+ * The driver will always use the "no-stall" approach for OUT transfers.
+ *
+ * One subtle point concerns sending status-stage responses for ep0
+ * requests.  Some of these requests, such as device reset, can involve
+ * interrupting an ongoing file I/O operation, which might take an
+ * arbitrarily long time.  During that delay the host might give up on
+ * the original ep0 request and issue a new one.  When that happens the
+ * driver should not notify the host about completion of the original
+ * request, as the host will no longer be waiting for it.  So the driver
+ * assigns to each ep0 request a unique tag, and it keeps track of the
+ * tag value of the request associated with a long-running exception
+ * (device-reset, interface-change, or configuration-change).  When the
+ * exception handler is finished, the status-stage response is submitted
+ * only if the current ep0 request tag is equal to the exception request
+ * tag.  Thus only the most recently received ep0 request will get a
+ * status-stage response.
+ *
+ * Warning: This driver source file is too long.  It ought to be split up
+ * into a header file plus about 3 separate .c files, to handle the details
+ * of the Gadget, USB Mass Storage, and SCSI protocols.
+ */
+
+
+/* #define VERBOSE_DEBUG */
+/* #define DUMP_MSGS */
+
+
+#include <linux/blkdev.h>
+#include <linux/completion.h>
+#include <linux/dcache.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/fcntl.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/kref.h>
+#include <linux/kthread.h>
+#include <linux/limits.h>
+#include <linux/rwsem.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/string.h>
+#include <linux/freezer.h>
+#include <linux/utsname.h>
+
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+#include "gadget_chips.h"
+
+
+
+/*------------------------------------------------------------------------*/
+
+#define FSG_DRIVER_DESC         "Mass Storage Function"
+#define FSG_DRIVER_VERSION      "2009/09/11"
+
+static const char fsg_string_interface[] = "Mass Storage";
+
+
+#define FSG_NO_INTR_EP 1
+#define FSG_BUFFHD_STATIC_BUFFER 1
+#define FSG_NO_DEVICE_STRINGS    1
+#define FSG_NO_OTG               1
+#define FSG_NO_INTR_EP           1
+
+#include "storage_common.c"
+
+
+/*-------------------------------------------------------------------------*/
+
+struct fsg_dev;
+
+
+/* Data shared by all the FSG instances. */
+struct fsg_common {
+        struct usb_gadget       *gadget;
+        struct fsg_dev          *fsg;
+        struct fsg_dev          *prev_fsg;
+
+        /* filesem protects: backing files in use */
+        struct rw_semaphore     filesem;
+
+        /* lock protects: state, all the req_busy's */
+        spinlock_t              lock;
+
+        struct usb_ep           *ep0;           /* Copy of gadget->ep0 */
+        struct usb_request      *ep0req;        /* Copy of cdev->req */
+        unsigned int            ep0_req_tag;
+        const char              *ep0req_name;
+
+        struct fsg_buffhd       *next_buffhd_to_fill;
+        struct fsg_buffhd       *next_buffhd_to_drain;
+        struct fsg_buffhd       buffhds[FSG_NUM_BUFFERS];
+
+        int                     cmnd_size;
+        u8                      cmnd[MAX_COMMAND_SIZE];
+
+        unsigned int            nluns;
+        unsigned int            lun;
+        struct fsg_lun          *luns;
+        struct fsg_lun          *curlun;
+
+        unsigned int            bulk_out_maxpacket;
+        enum fsg_state          state;          /* For exception handling */
+        unsigned int            exception_req_tag;
+
+        u8                      config, new_config;
+        enum data_direction     data_dir;
+        u32                     data_size;
+        u32                     data_size_from_cmnd;
+        u32                     tag;
+        u32                     residue;
+        u32                     usb_amount_left;
+
+        unsigned int            can_stall:1;
+        unsigned int            free_storage_on_release:1;
+        unsigned int            phase_error:1;
+        unsigned int            short_packet_received:1;
+        unsigned int            bad_lun_okay:1;
+        unsigned int            running:1;
+
+        int                     thread_wakeup_needed;
+        struct completion       thread_notifier;
+        struct task_struct      *thread_task;
+
+        /* Callback function to call when thread exits. */
+        int                     (*thread_exits)(struct fsg_common *common);
+        /* Gadget's private data. */
+        void                    *private_data;
+
+        /* Vendor (8 chars), product (16 chars), release (4
+         * hexadecimal digits) and NUL byte */
+        char inquiry_string[8 + 16 + 4 + 1];
+
+        struct kref             ref;
+};
+
+
+struct fsg_config {
+        unsigned nluns;
+        struct fsg_lun_config {
+                const char *filename;
+                char ro;
+                char removable;
+                char cdrom;
+        } luns[FSG_MAX_LUNS];
+
+        const char              *lun_name_format;
+        const char              *thread_name;
+
+        /* Callback function to call when thread exits.  If no
+         * callback is set or it returns value lower then zero MSF
+         * will force eject all LUNs it operates on (including those
+         * marked as non-removable or with prevent_medium_removal flag
+         * set). */
+        int                     (*thread_exits)(struct fsg_common *common);
+        /* Gadget's private data. */
+        void                    *private_data;
+
+        const char *vendor_name;                /*  8 characters or less */
+        const char *product_name;               /* 16 characters or less */
+        u16 release;
+
+        char                    can_stall;
+};
+
+
+struct fsg_dev {
+        struct usb_function     function;
+        struct usb_gadget       *gadget;        /* Copy of cdev->gadget */
+        struct fsg_common       *common;
+
+        u16                     interface_number;
+
+        unsigned int            bulk_in_enabled:1;
+        unsigned int            bulk_out_enabled:1;
+
+        unsigned long           atomic_bitflags;
+#define IGNORE_BULK_OUT         0
+
+        struct usb_ep           *bulk_in;
+        struct usb_ep           *bulk_out;
+};
+
+
+static inline int __fsg_is_set(struct fsg_common *common,
+                               const char *func, unsigned line)
+{
+        if (common->fsg)
+                return 1;
+        ERROR(common, "common->fsg is NULL in %s at %u\n", func, line);
+        return 0;
+}
+
+#define fsg_is_set(common) likely(__fsg_is_set(common, __func__, __LINE__))
+
+
+static inline struct fsg_dev *fsg_from_func(struct usb_function *f)
+{
+        return container_of(f, struct fsg_dev, function);
+}
+
+
+typedef void (*fsg_routine_t)(struct fsg_dev *);
+
+static int exception_in_progress(struct fsg_common *common)
+{
+        return common->state > FSG_STATE_IDLE;
+}
+
+/* Make bulk-out requests be divisible by the maxpacket size */
+static void set_bulk_out_req_length(struct fsg_common *common,
+                struct fsg_buffhd *bh, unsigned int length)
+{
+        unsigned int    rem;
+
+        bh->bulk_out_intended_length = length;
+        rem = length % common->bulk_out_maxpacket;
+        if (rem > 0)
+                length += common->bulk_out_maxpacket - rem;
+        bh->outreq->length = length;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
+{
+        const char      *name;
+
+        if (ep == fsg->bulk_in)
+                name = "bulk-in";
+        else if (ep == fsg->bulk_out)
+                name = "bulk-out";
+        else
+                name = ep->name;
+        DBG(fsg, "%s set halt\n", name);
+        return usb_ep_set_halt(ep);
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+/* These routines may be called in process context or in_irq */
+
+/* Caller must hold fsg->lock */
+static void wakeup_thread(struct fsg_common *common)
+{
+        /* Tell the main thread that something has happened */
+        common->thread_wakeup_needed = 1;
+        if (common->thread_task)
+                wake_up_process(common->thread_task);
+}
+
+
+static void raise_exception(struct fsg_common *common, enum fsg_state new_state)
+{
+        unsigned long           flags;
+
+        /* Do nothing if a higher-priority exception is already in progress.
+         * If a lower-or-equal priority exception is in progress, preempt it
+         * and notify the main thread by sending it a signal. */
+        spin_lock_irqsave(&common->lock, flags);
+        if (common->state <= new_state) {
+                common->exception_req_tag = common->ep0_req_tag;
+                common->state = new_state;
+                if (common->thread_task)
+                        send_sig_info(SIGUSR1, SEND_SIG_FORCED,
+                                      common->thread_task);
+        }
+        spin_unlock_irqrestore(&common->lock, flags);
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int ep0_queue(struct fsg_common *common)
+{
+        int     rc;
+
+        rc = usb_ep_queue(common->ep0, common->ep0req, GFP_ATOMIC);
+        common->ep0->driver_data = common;
+        if (rc != 0 && rc != -ESHUTDOWN) {
+                /* We can't do much more than wait for a reset */
+                WARNING(common, "error in submission: %s --> %d\n",
+                        common->ep0->name, rc);
+        }
+        return rc;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* Bulk and interrupt endpoint completion handlers.
+ * These always run in_irq. */
+
+static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct fsg_common       *common = ep->driver_data;
+        struct fsg_buffhd       *bh = req->context;
+
+        if (req->status || req->actual != req->length)
+                DBG(common, "%s --> %d, %u/%u\n", __func__,
+                                req->status, req->actual, req->length);
+        if (req->status == -ECONNRESET)         /* Request was cancelled */
+                usb_ep_fifo_flush(ep);
+
+        /* Hold the lock while we update the request and buffer states */
+        smp_wmb();
+        spin_lock(&common->lock);
+        bh->inreq_busy = 0;
+        bh->state = BUF_STATE_EMPTY;
+        wakeup_thread(common);
+        spin_unlock(&common->lock);
+}
+
+static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct fsg_common       *common = ep->driver_data;
+        struct fsg_buffhd       *bh = req->context;
+
+        dump_msg(common, "bulk-out", req->buf, req->actual);
+        if (req->status || req->actual != bh->bulk_out_intended_length)
+                DBG(common, "%s --> %d, %u/%u\n", __func__,
+                                req->status, req->actual,
+                                bh->bulk_out_intended_length);
+        if (req->status == -ECONNRESET)         /* Request was cancelled */
+                usb_ep_fifo_flush(ep);
+
+        /* Hold the lock while we update the request and buffer states */
+        smp_wmb();
+        spin_lock(&common->lock);
+        bh->outreq_busy = 0;
+        bh->state = BUF_STATE_FULL;
+        wakeup_thread(common);
+        spin_unlock(&common->lock);
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+/* Ep0 class-specific handlers.  These always run in_irq. */
+
+static int fsg_setup(struct usb_function *f,
+                const struct usb_ctrlrequest *ctrl)
+{
+        struct fsg_dev          *fsg = fsg_from_func(f);
+        struct usb_request      *req = fsg->common->ep0req;
+        u16                     w_index = le16_to_cpu(ctrl->wIndex);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+        u16                     w_length = le16_to_cpu(ctrl->wLength);
+
+        if (!fsg->common->config)
+                return -EOPNOTSUPP;
+
+        switch (ctrl->bRequest) {
+
+        case USB_BULK_RESET_REQUEST:
+                if (ctrl->bRequestType !=
+                    (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
+                        break;
+                if (w_index != fsg->interface_number || w_value != 0)
+                        return -EDOM;
+
+                /* Raise an exception to stop the current operation
+                 * and reinitialize our state. */
+                DBG(fsg, "bulk reset request\n");
+                raise_exception(fsg->common, FSG_STATE_RESET);
+                return DELAYED_STATUS;
+
+        case USB_BULK_GET_MAX_LUN_REQUEST:
+                if (ctrl->bRequestType !=
+                    (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
+                        break;
+                if (w_index != fsg->interface_number || w_value != 0)
+                        return -EDOM;
+                VDBG(fsg, "get max LUN\n");
+                *(u8 *) req->buf = fsg->common->nluns - 1;
+
+                /* Respond with data/status */
+                req->length = min((u16)1, w_length);
+                fsg->common->ep0req_name =
+                        ctrl->bRequestType & USB_DIR_IN ? "ep0-in" : "ep0-out";
+                return ep0_queue(fsg->common);
+        }
+
+        VDBG(fsg,
+             "unknown class-specific control req "
+             "%02x.%02x v%04x i%04x l%u\n",
+             ctrl->bRequestType, ctrl->bRequest,
+             le16_to_cpu(ctrl->wValue), w_index, w_length);
+        return -EOPNOTSUPP;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+/* All the following routines run in process context */
+
+
+/* Use this for bulk or interrupt transfers, not ep0 */
+static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
+                struct usb_request *req, int *pbusy,
+                enum fsg_buffer_state *state)
+{
+        int     rc;
+
+        if (ep == fsg->bulk_in)
+                dump_msg(fsg, "bulk-in", req->buf, req->length);
+
+        spin_lock_irq(&fsg->common->lock);
+        *pbusy = 1;
+        *state = BUF_STATE_BUSY;
+        spin_unlock_irq(&fsg->common->lock);
+        rc = usb_ep_queue(ep, req, GFP_KERNEL);
+        if (rc != 0) {
+                *pbusy = 0;
+                *state = BUF_STATE_EMPTY;
+
+                /* We can't do much more than wait for a reset */
+
+                /* Note: currently the net2280 driver fails zero-length
+                 * submissions if DMA is enabled. */
+                if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP &&
+                                                req->length == 0))
+                        WARNING(fsg, "error in submission: %s --> %d\n",
+                                        ep->name, rc);
+        }
+}
+
+#define START_TRANSFER_OR(common, ep_name, req, pbusy, state)           \
+        if (fsg_is_set(common))                                         \
+                start_transfer((common)->fsg, (common)->fsg->ep_name,   \
+                               req, pbusy, state);                      \
+        else
+
+#define START_TRANSFER(common, ep_name, req, pbusy, state)              \
+        START_TRANSFER_OR(common, ep_name, req, pbusy, state) (void)0
+
+
+
+static int sleep_thread(struct fsg_common *common)
+{
+        int     rc = 0;
+
+        /* Wait until a signal arrives or we are woken up */
+        for (;;) {
+                try_to_freeze();
+                set_current_state(TASK_INTERRUPTIBLE);
+                if (signal_pending(current)) {
+                        rc = -EINTR;
+                        break;
+                }
+                if (common->thread_wakeup_needed)
+                        break;
+                schedule();
+        }
+        __set_current_state(TASK_RUNNING);
+        common->thread_wakeup_needed = 0;
+        return rc;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int do_read(struct fsg_common *common)
+{
+        struct fsg_lun          *curlun = common->curlun;
+        u32                     lba;
+        struct fsg_buffhd       *bh;
+        int                     rc;
+        u32                     amount_left;
+        loff_t                  file_offset, file_offset_tmp;
+        unsigned int            amount;
+        unsigned int            partial_page;
+        ssize_t                 nread;
+
+        /* Get the starting Logical Block Address and check that it's
+         * not too big */
+        if (common->cmnd[0] == SC_READ_6)
+                lba = get_unaligned_be24(&common->cmnd[1]);
+        else {
+                lba = get_unaligned_be32(&common->cmnd[2]);
+
+                /* We allow DPO (Disable Page Out = don't save data in the
+                 * cache) and FUA (Force Unit Access = don't read from the
+                 * cache), but we don't implement them. */
+                if ((common->cmnd[1] & ~0x18) != 0) {
+                        curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                        return -EINVAL;
+                }
+        }
+        if (lba >= curlun->num_sectors) {
+                curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
+                return -EINVAL;
+        }
+        file_offset = ((loff_t) lba) << 9;
+
+        /* Carry out the file reads */
+        amount_left = common->data_size_from_cmnd;
+        if (unlikely(amount_left == 0))
+                return -EIO;            /* No default reply */
+
+        for (;;) {
+
+                /* Figure out how much we need to read:
+                 * Try to read the remaining amount.
+                 * But don't read more than the buffer size.
+                 * And don't try to read past the end of the file.
+                 * Finally, if we're not at a page boundary, don't read past
+                 *      the next page.
+                 * If this means reading 0 then we were asked to read past
+                 *      the end of file. */
+                amount = min(amount_left, FSG_BUFLEN);
+                amount = min((loff_t) amount,
+                                curlun->file_length - file_offset);
+                partial_page = file_offset & (PAGE_CACHE_SIZE - 1);
+                if (partial_page > 0)
+                        amount = min(amount, (unsigned int) PAGE_CACHE_SIZE -
+                                        partial_page);
+
+                /* Wait for the next buffer to become available */
+                bh = common->next_buffhd_to_fill;
+                while (bh->state != BUF_STATE_EMPTY) {
+                        rc = sleep_thread(common);
+                        if (rc)
+                                return rc;
+                }
+
+                /* If we were asked to read past the end of file,
+                 * end with an empty buffer. */
+                if (amount == 0) {
+                        curlun->sense_data =
+                                        SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
+                        curlun->sense_data_info = file_offset >> 9;
+                        curlun->info_valid = 1;
+                        bh->inreq->length = 0;
+                        bh->state = BUF_STATE_FULL;
+                        break;
+                }
+
+                /* Perform the read */
+                file_offset_tmp = file_offset;
+                nread = vfs_read(curlun->filp,
+                                (char __user *) bh->buf,
+                                amount, &file_offset_tmp);
+                VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
+                                (unsigned long long) file_offset,
+                                (int) nread);
+                if (signal_pending(current))
+                        return -EINTR;
+
+                if (nread < 0) {
+                        LDBG(curlun, "error in file read: %d\n",
+                                        (int) nread);
+                        nread = 0;
+                } else if (nread < amount) {
+                        LDBG(curlun, "partial file read: %d/%u\n",
+                                        (int) nread, amount);
+                        nread -= (nread & 511); /* Round down to a block */
+                }
+                file_offset  += nread;
+                amount_left  -= nread;
+                common->residue -= nread;
+                bh->inreq->length = nread;
+                bh->state = BUF_STATE_FULL;
+
+                /* If an error occurred, report it and its position */
+                if (nread < amount) {
+                        curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
+                        curlun->sense_data_info = file_offset >> 9;
+                        curlun->info_valid = 1;
+                        break;
+                }
+
+                if (amount_left == 0)
+                        break;          /* No more left to read */
+
+                /* Send this buffer and go read some more */
+                bh->inreq->zero = 0;
+                START_TRANSFER_OR(common, bulk_in, bh->inreq,
+                               &bh->inreq_busy, &bh->state)
+                        /* Don't know what to do if
+                         * common->fsg is NULL */
+                        return -EIO;
+                common->next_buffhd_to_fill = bh->next;
+        }
+
+        return -EIO;            /* No default reply */
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int do_write(struct fsg_common *common)
+{
+        struct fsg_lun          *curlun = common->curlun;
+        u32                     lba;
+        struct fsg_buffhd       *bh;
+        int                     get_some_more;
+        u32                     amount_left_to_req, amount_left_to_write;
+        loff_t                  usb_offset, file_offset, file_offset_tmp;
+        unsigned int            amount;
+        unsigned int            partial_page;
+        ssize_t                 nwritten;
+        int                     rc;
+
+        if (curlun->ro) {
+                curlun->sense_data = SS_WRITE_PROTECTED;
+                return -EINVAL;
+        }
+        spin_lock(&curlun->filp->f_lock);
+        curlun->filp->f_flags &= ~O_SYNC;       /* Default is not to wait */
+        spin_unlock(&curlun->filp->f_lock);
+
+        /* Get the starting Logical Block Address and check that it's
+         * not too big */
+        if (common->cmnd[0] == SC_WRITE_6)
+                lba = get_unaligned_be24(&common->cmnd[1]);
+        else {
+                lba = get_unaligned_be32(&common->cmnd[2]);
+
+                /* We allow DPO (Disable Page Out = don't save data in the
+                 * cache) and FUA (Force Unit Access = write directly to the
+                 * medium).  We don't implement DPO; we implement FUA by
+                 * performing synchronous output. */
+                if (common->cmnd[1] & ~0x18) {
+                        curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                        return -EINVAL;
+                }
+                if (common->cmnd[1] & 0x08) {   /* FUA */
+                        spin_lock(&curlun->filp->f_lock);
+                        curlun->filp->f_flags |= O_SYNC;
+                        spin_unlock(&curlun->filp->f_lock);
+                }
+        }
+        if (lba >= curlun->num_sectors) {
+                curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
+                return -EINVAL;
+        }
+
+        /* Carry out the file writes */
+        get_some_more = 1;
+        file_offset = usb_offset = ((loff_t) lba) << 9;
+        amount_left_to_req = common->data_size_from_cmnd;
+        amount_left_to_write = common->data_size_from_cmnd;
+
+        while (amount_left_to_write > 0) {
+
+                /* Queue a request for more data from the host */
+                bh = common->next_buffhd_to_fill;
+                if (bh->state == BUF_STATE_EMPTY && get_some_more) {
+
+                        /* Figure out how much we want to get:
+                         * Try to get the remaining amount.
+                         * But don't get more than the buffer size.
+                         * And don't try to go past the end of the file.
+                         * If we're not at a page boundary,
+                         *      don't go past the next page.
+                         * If this means getting 0, then we were asked
+                         *      to write past the end of file.
+                         * Finally, round down to a block boundary. */
+                        amount = min(amount_left_to_req, FSG_BUFLEN);
+                        amount = min((loff_t) amount, curlun->file_length -
+                                        usb_offset);
+                        partial_page = usb_offset & (PAGE_CACHE_SIZE - 1);
+                        if (partial_page > 0)
+                                amount = min(amount,
+        (unsigned int) PAGE_CACHE_SIZE - partial_page);
+
+                        if (amount == 0) {
+                                get_some_more = 0;
+                                curlun->sense_data =
+                                        SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
+                                curlun->sense_data_info = usb_offset >> 9;
+                                curlun->info_valid = 1;
+                                continue;
+                        }
+                        amount -= (amount & 511);
+                        if (amount == 0) {
+
+                                /* Why were we were asked to transfer a
+                                 * partial block? */
+                                get_some_more = 0;
+                                continue;
+                        }
+
+                        /* Get the next buffer */
+                        usb_offset += amount;
+                        common->usb_amount_left -= amount;
+                        amount_left_to_req -= amount;
+                        if (amount_left_to_req == 0)
+                                get_some_more = 0;
+
+                        /* amount is always divisible by 512, hence by
+                         * the bulk-out maxpacket size */
+                        bh->outreq->length = amount;
+                        bh->bulk_out_intended_length = amount;
+                        bh->outreq->short_not_ok = 1;
+                        START_TRANSFER_OR(common, bulk_out, bh->outreq,
+                                          &bh->outreq_busy, &bh->state)
+                                /* Don't know what to do if
+                                 * common->fsg is NULL */
+                                return -EIO;
+                        common->next_buffhd_to_fill = bh->next;
+                        continue;
+                }
+
+                /* Write the received data to the backing file */
+                bh = common->next_buffhd_to_drain;
+                if (bh->state == BUF_STATE_EMPTY && !get_some_more)
+                        break;                  /* We stopped early */
+                if (bh->state == BUF_STATE_FULL) {
+                        smp_rmb();
+                        common->next_buffhd_to_drain = bh->next;
+                        bh->state = BUF_STATE_EMPTY;
+
+                        /* Did something go wrong with the transfer? */
+                        if (bh->outreq->status != 0) {
+                                curlun->sense_data = SS_COMMUNICATION_FAILURE;
+                                curlun->sense_data_info = file_offset >> 9;
+                                curlun->info_valid = 1;
+                                break;
+                        }
+
+                        amount = bh->outreq->actual;
+                        if (curlun->file_length - file_offset < amount) {
+                                LERROR(curlun,
+        "write %u @ %llu beyond end %llu\n",
+        amount, (unsigned long long) file_offset,
+        (unsigned long long) curlun->file_length);
+                                amount = curlun->file_length - file_offset;
+                        }
+
+                        /* Perform the write */
+                        file_offset_tmp = file_offset;
+                        nwritten = vfs_write(curlun->filp,
+                                        (char __user *) bh->buf,
+                                        amount, &file_offset_tmp);
+                        VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
+                                        (unsigned long long) file_offset,
+                                        (int) nwritten);
+                        if (signal_pending(current))
+                                return -EINTR;          /* Interrupted! */
+
+                        if (nwritten < 0) {
+                                LDBG(curlun, "error in file write: %d\n",
+                                                (int) nwritten);
+                                nwritten = 0;
+                        } else if (nwritten < amount) {
+                                LDBG(curlun, "partial file write: %d/%u\n",
+                                                (int) nwritten, amount);
+                                nwritten -= (nwritten & 511);
+                                /* Round down to a block */
+                        }
+                        file_offset += nwritten;
+                        amount_left_to_write -= nwritten;
+                        common->residue -= nwritten;
+
+                        /* If an error occurred, report it and its position */
+                        if (nwritten < amount) {
+                                curlun->sense_data = SS_WRITE_ERROR;
+                                curlun->sense_data_info = file_offset >> 9;
+                                curlun->info_valid = 1;
+                                break;
+                        }
+
+                        /* Did the host decide to stop early? */
+                        if (bh->outreq->actual != bh->outreq->length) {
+                                common->short_packet_received = 1;
+                                break;
+                        }
+                        continue;
+                }
+
+                /* Wait for something to happen */
+                rc = sleep_thread(common);
+                if (rc)
+                        return rc;
+        }
+
+        return -EIO;            /* No default reply */
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int do_synchronize_cache(struct fsg_common *common)
+{
+        struct fsg_lun  *curlun = common->curlun;
+        int             rc;
+
+        /* We ignore the requested LBA and write out all file's
+         * dirty data buffers. */
+        rc = fsg_lun_fsync_sub(curlun);
+        if (rc)
+                curlun->sense_data = SS_WRITE_ERROR;
+        return 0;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static void invalidate_sub(struct fsg_lun *curlun)
+{
+        struct file     *filp = curlun->filp;
+        struct inode    *inode = filp->f_path.dentry->d_inode;
+        unsigned long   rc;
+
+        rc = invalidate_mapping_pages(inode->i_mapping, 0, -1);
+        VLDBG(curlun, "invalidate_mapping_pages -> %ld\n", rc);
+}
+
+static int do_verify(struct fsg_common *common)
+{
+        struct fsg_lun          *curlun = common->curlun;
+        u32                     lba;
+        u32                     verification_length;
+        struct fsg_buffhd       *bh = common->next_buffhd_to_fill;
+        loff_t                  file_offset, file_offset_tmp;
+        u32                     amount_left;
+        unsigned int            amount;
+        ssize_t                 nread;
+
+        /* Get the starting Logical Block Address and check that it's
+         * not too big */
+        lba = get_unaligned_be32(&common->cmnd[2]);
+        if (lba >= curlun->num_sectors) {
+                curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
+                return -EINVAL;
+        }
+
+        /* We allow DPO (Disable Page Out = don't save data in the
+         * cache) but we don't implement it. */
+        if (common->cmnd[1] & ~0x10) {
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+
+        verification_length = get_unaligned_be16(&common->cmnd[7]);
+        if (unlikely(verification_length == 0))
+                return -EIO;            /* No default reply */
+
+        /* Prepare to carry out the file verify */
+        amount_left = verification_length << 9;
+        file_offset = ((loff_t) lba) << 9;
+
+        /* Write out all the dirty buffers before invalidating them */
+        fsg_lun_fsync_sub(curlun);
+        if (signal_pending(current))
+                return -EINTR;
+
+        invalidate_sub(curlun);
+        if (signal_pending(current))
+                return -EINTR;
+
+        /* Just try to read the requested blocks */
+        while (amount_left > 0) {
+
+                /* Figure out how much we need to read:
+                 * Try to read the remaining amount, but not more than
+                 * the buffer size.
+                 * And don't try to read past the end of the file.
+                 * If this means reading 0 then we were asked to read
+                 * past the end of file. */
+                amount = min(amount_left, FSG_BUFLEN);
+                amount = min((loff_t) amount,
+                                curlun->file_length - file_offset);
+                if (amount == 0) {
+                        curlun->sense_data =
+                                        SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
+                        curlun->sense_data_info = file_offset >> 9;
+                        curlun->info_valid = 1;
+                        break;
+                }
+
+                /* Perform the read */
+                file_offset_tmp = file_offset;
+                nread = vfs_read(curlun->filp,
+                                (char __user *) bh->buf,
+                                amount, &file_offset_tmp);
+                VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
+                                (unsigned long long) file_offset,
+                                (int) nread);
+                if (signal_pending(current))
+                        return -EINTR;
+
+                if (nread < 0) {
+                        LDBG(curlun, "error in file verify: %d\n",
+                                        (int) nread);
+                        nread = 0;
+                } else if (nread < amount) {
+                        LDBG(curlun, "partial file verify: %d/%u\n",
+                                        (int) nread, amount);
+                        nread -= (nread & 511); /* Round down to a sector */
+                }
+                if (nread == 0) {
+                        curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
+                        curlun->sense_data_info = file_offset >> 9;
+                        curlun->info_valid = 1;
+                        break;
+                }
+                file_offset += nread;
+                amount_left -= nread;
+        }
+        return 0;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        struct fsg_lun *curlun = common->curlun;
+        u8      *buf = (u8 *) bh->buf;
+
+        if (!curlun) {          /* Unsupported LUNs are okay */
+                common->bad_lun_okay = 1;
+                memset(buf, 0, 36);
+                buf[0] = 0x7f;          /* Unsupported, no device-type */
+                buf[4] = 31;            /* Additional length */
+                return 36;
+        }
+
+        buf[0] = curlun->cdrom ? TYPE_CDROM : TYPE_DISK;
+        buf[1] = curlun->removable ? 0x80 : 0;
+        buf[2] = 2;             /* ANSI SCSI level 2 */
+        buf[3] = 2;             /* SCSI-2 INQUIRY data format */
+        buf[4] = 31;            /* Additional length */
+        buf[5] = 0;             /* No special options */
+        buf[6] = 0;
+        buf[7] = 0;
+        memcpy(buf + 8, common->inquiry_string, sizeof common->inquiry_string);
+        return 36;
+}
+
+
+static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        struct fsg_lun  *curlun = common->curlun;
+        u8              *buf = (u8 *) bh->buf;
+        u32             sd, sdinfo;
+        int             valid;
+
+        /*
+         * From the SCSI-2 spec., section 7.9 (Unit attention condition):
+         *
+         * If a REQUEST SENSE command is received from an initiator
+         * with a pending unit attention condition (before the target
+         * generates the contingent allegiance condition), then the
+         * target shall either:
+         *   a) report any pending sense data and preserve the unit
+         *      attention condition on the logical unit, or,
+         *   b) report the unit attention condition, may discard any
+         *      pending sense data, and clear the unit attention
+         *      condition on the logical unit for that initiator.
+         *
+         * FSG normally uses option a); enable this code to use option b).
+         */
+#if 0
+        if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
+                curlun->sense_data = curlun->unit_attention_data;
+                curlun->unit_attention_data = SS_NO_SENSE;
+        }
+#endif
+
+        if (!curlun) {          /* Unsupported LUNs are okay */
+                common->bad_lun_okay = 1;
+                sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
+                sdinfo = 0;
+                valid = 0;
+        } else {
+                sd = curlun->sense_data;
+                sdinfo = curlun->sense_data_info;
+                valid = curlun->info_valid << 7;
+                curlun->sense_data = SS_NO_SENSE;
+                curlun->sense_data_info = 0;
+                curlun->info_valid = 0;
+        }
+
+        memset(buf, 0, 18);
+        buf[0] = valid | 0x70;                  /* Valid, current error */
+        buf[2] = SK(sd);
+        put_unaligned_be32(sdinfo, &buf[3]);    /* Sense information */
+        buf[7] = 18 - 8;                        /* Additional sense length */
+        buf[12] = ASC(sd);
+        buf[13] = ASCQ(sd);
+        return 18;
+}
+
+
+static int do_read_capacity(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        struct fsg_lun  *curlun = common->curlun;
+        u32             lba = get_unaligned_be32(&common->cmnd[2]);
+        int             pmi = common->cmnd[8];
+        u8              *buf = (u8 *) bh->buf;
+
+        /* Check the PMI and LBA fields */
+        if (pmi > 1 || (pmi == 0 && lba != 0)) {
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+
+        put_unaligned_be32(curlun->num_sectors - 1, &buf[0]);
+                                                /* Max logical block */
+        put_unaligned_be32(512, &buf[4]);       /* Block length */
+        return 8;
+}
+
+
+static int do_read_header(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        struct fsg_lun  *curlun = common->curlun;
+        int             msf = common->cmnd[1] & 0x02;
+        u32             lba = get_unaligned_be32(&common->cmnd[2]);
+        u8              *buf = (u8 *) bh->buf;
+
+        if (common->cmnd[1] & ~0x02) {          /* Mask away MSF */
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+        if (lba >= curlun->num_sectors) {
+                curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
+                return -EINVAL;
+        }
+
+        memset(buf, 0, 8);
+        buf[0] = 0x01;          /* 2048 bytes of user data, rest is EC */
+        store_cdrom_address(&buf[4], msf, lba);
+        return 8;
+}
+
+
+static int do_read_toc(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        struct fsg_lun  *curlun = common->curlun;
+        int             msf = common->cmnd[1] & 0x02;
+        int             start_track = common->cmnd[6];
+        u8              *buf = (u8 *) bh->buf;
+
+        if ((common->cmnd[1] & ~0x02) != 0 ||   /* Mask away MSF */
+                        start_track > 1) {
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+
+        memset(buf, 0, 20);
+        buf[1] = (20-2);                /* TOC data length */
+        buf[2] = 1;                     /* First track number */
+        buf[3] = 1;                     /* Last track number */
+        buf[5] = 0x16;                  /* Data track, copying allowed */
+        buf[6] = 0x01;                  /* Only track is number 1 */
+        store_cdrom_address(&buf[8], msf, 0);
+
+        buf[13] = 0x16;                 /* Lead-out track is data */
+        buf[14] = 0xAA;                 /* Lead-out track number */
+        store_cdrom_address(&buf[16], msf, curlun->num_sectors);
+        return 20;
+}
+
+
+static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        struct fsg_lun  *curlun = common->curlun;
+        int             mscmnd = common->cmnd[0];
+        u8              *buf = (u8 *) bh->buf;
+        u8              *buf0 = buf;
+        int             pc, page_code;
+        int             changeable_values, all_pages;
+        int             valid_page = 0;
+        int             len, limit;
+
+        if ((common->cmnd[1] & ~0x08) != 0) {   /* Mask away DBD */
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+        pc = common->cmnd[2] >> 6;
+        page_code = common->cmnd[2] & 0x3f;
+        if (pc == 3) {
+                curlun->sense_data = SS_SAVING_PARAMETERS_NOT_SUPPORTED;
+                return -EINVAL;
+        }
+        changeable_values = (pc == 1);
+        all_pages = (page_code == 0x3f);
+
+        /* Write the mode parameter header.  Fixed values are: default
+         * medium type, no cache control (DPOFUA), and no block descriptors.
+         * The only variable value is the WriteProtect bit.  We will fill in
+         * the mode data length later. */
+        memset(buf, 0, 8);
+        if (mscmnd == SC_MODE_SENSE_6) {
+                buf[2] = (curlun->ro ? 0x80 : 0x00);            /* WP, DPOFUA */
+                buf += 4;
+                limit = 255;
+        } else {                        /* SC_MODE_SENSE_10 */
+                buf[3] = (curlun->ro ? 0x80 : 0x00);            /* WP, DPOFUA */
+                buf += 8;
+                limit = 65535;          /* Should really be FSG_BUFLEN */
+        }
+
+        /* No block descriptors */
+
+        /* The mode pages, in numerical order.  The only page we support
+         * is the Caching page. */
+        if (page_code == 0x08 || all_pages) {
+                valid_page = 1;
+                buf[0] = 0x08;          /* Page code */
+                buf[1] = 10;            /* Page length */
+                memset(buf+2, 0, 10);   /* None of the fields are changeable */
+
+                if (!changeable_values) {
+                        buf[2] = 0x04;  /* Write cache enable, */
+                                        /* Read cache not disabled */
+                                        /* No cache retention priorities */
+                        put_unaligned_be16(0xffff, &buf[4]);
+                                        /* Don't disable prefetch */
+                                        /* Minimum prefetch = 0 */
+                        put_unaligned_be16(0xffff, &buf[8]);
+                                        /* Maximum prefetch */
+                        put_unaligned_be16(0xffff, &buf[10]);
+                                        /* Maximum prefetch ceiling */
+                }
+                buf += 12;
+        }
+
+        /* Check that a valid page was requested and the mode data length
+         * isn't too long. */
+        len = buf - buf0;
+        if (!valid_page || len > limit) {
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+
+        /*  Store the mode data length */
+        if (mscmnd == SC_MODE_SENSE_6)
+                buf0[0] = len - 1;
+        else
+                put_unaligned_be16(len - 2, buf0);
+        return len;
+}
+
+
+static int do_start_stop(struct fsg_common *common)
+{
+        if (!common->curlun) {
+                return -EINVAL;
+        } else if (!common->curlun->removable) {
+                common->curlun->sense_data = SS_INVALID_COMMAND;
+                return -EINVAL;
+        }
+        return 0;
+}
+
+
+static int do_prevent_allow(struct fsg_common *common)
+{
+        struct fsg_lun  *curlun = common->curlun;
+        int             prevent;
+
+        if (!common->curlun) {
+                return -EINVAL;
+        } else if (!common->curlun->removable) {
+                common->curlun->sense_data = SS_INVALID_COMMAND;
+                return -EINVAL;
+        }
+
+        prevent = common->cmnd[4] & 0x01;
+        if ((common->cmnd[4] & ~0x01) != 0) {   /* Mask away Prevent */
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+
+        if (curlun->prevent_medium_removal && !prevent)
+                fsg_lun_fsync_sub(curlun);
+        curlun->prevent_medium_removal = prevent;
+        return 0;
+}
+
+
+static int do_read_format_capacities(struct fsg_common *common,
+                        struct fsg_buffhd *bh)
+{
+        struct fsg_lun  *curlun = common->curlun;
+        u8              *buf = (u8 *) bh->buf;
+
+        buf[0] = buf[1] = buf[2] = 0;
+        buf[3] = 8;     /* Only the Current/Maximum Capacity Descriptor */
+        buf += 4;
+
+        put_unaligned_be32(curlun->num_sectors, &buf[0]);
+                                                /* Number of blocks */
+        put_unaligned_be32(512, &buf[4]);       /* Block length */
+        buf[4] = 0x02;                          /* Current capacity */
+        return 12;
+}
+
+
+static int do_mode_select(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        struct fsg_lun  *curlun = common->curlun;
+
+        /* We don't support MODE SELECT */
+        if (curlun)
+                curlun->sense_data = SS_INVALID_COMMAND;
+        return -EINVAL;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int halt_bulk_in_endpoint(struct fsg_dev *fsg)
+{
+        int     rc;
+
+        rc = fsg_set_halt(fsg, fsg->bulk_in);
+        if (rc == -EAGAIN)
+                VDBG(fsg, "delayed bulk-in endpoint halt\n");
+        while (rc != 0) {
+                if (rc != -EAGAIN) {
+                        WARNING(fsg, "usb_ep_set_halt -> %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_halt(fsg->bulk_in);
+        }
+        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) {
+                        WARNING(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->common->next_buffhd_to_fill;
+        u32                     nkeep = bh->inreq->length;
+        u32                     nsend;
+        int                     rc;
+
+        bh->state = BUF_STATE_EMPTY;            /* For the first iteration */
+        fsg->common->usb_amount_left = nkeep + fsg->common->residue;
+        while (fsg->common->usb_amount_left > 0) {
+
+                /* Wait for the next buffer to be free */
+                while (bh->state != BUF_STATE_EMPTY) {
+                        rc = sleep_thread(fsg->common);
+                        if (rc)
+                                return rc;
+                }
+
+                nsend = min(fsg->common->usb_amount_left, FSG_BUFLEN);
+                memset(bh->buf + nkeep, 0, nsend - nkeep);
+                bh->inreq->length = nsend;
+                bh->inreq->zero = 0;
+                start_transfer(fsg, fsg->bulk_in, bh->inreq,
+                                &bh->inreq_busy, &bh->state);
+                bh = fsg->common->next_buffhd_to_fill = bh->next;
+                fsg->common->usb_amount_left -= nsend;
+                nkeep = 0;
+        }
+        return 0;
+}
+
+static int throw_away_data(struct fsg_common *common)
+{
+        struct fsg_buffhd       *bh;
+        u32                     amount;
+        int                     rc;
+
+        for (bh = common->next_buffhd_to_drain;
+             bh->state != BUF_STATE_EMPTY || common->usb_amount_left > 0;
+             bh = common->next_buffhd_to_drain) {
+
+                /* Throw away the data in a filled buffer */
+                if (bh->state == BUF_STATE_FULL) {
+                        smp_rmb();
+                        bh->state = BUF_STATE_EMPTY;
+                        common->next_buffhd_to_drain = bh->next;
+
+                        /* A short packet or an error ends everything */
+                        if (bh->outreq->actual != bh->outreq->length ||
+                                        bh->outreq->status != 0) {
+                                raise_exception(common,
+                                                FSG_STATE_ABORT_BULK_OUT);
+                                return -EINTR;
+                        }
+                        continue;
+                }
+
+                /* Try to submit another request if we need one */
+                bh = common->next_buffhd_to_fill;
+                if (bh->state == BUF_STATE_EMPTY
+                 && common->usb_amount_left > 0) {
+                        amount = min(common->usb_amount_left, FSG_BUFLEN);
+
+                        /* amount is always divisible by 512, hence by
+                         * the bulk-out maxpacket size */
+                        bh->outreq->length = amount;
+                        bh->bulk_out_intended_length = amount;
+                        bh->outreq->short_not_ok = 1;
+                        START_TRANSFER_OR(common, bulk_out, bh->outreq,
+                                          &bh->outreq_busy, &bh->state)
+                                /* Don't know what to do if
+                                 * common->fsg is NULL */
+                                return -EIO;
+                        common->next_buffhd_to_fill = bh->next;
+                        common->usb_amount_left -= amount;
+                        continue;
+                }
+
+                /* Otherwise wait for something to happen */
+                rc = sleep_thread(common);
+                if (rc)
+                        return rc;
+        }
+        return 0;
+}
+
+
+static int finish_reply(struct fsg_common *common)
+{
+        struct fsg_buffhd       *bh = common->next_buffhd_to_fill;
+        int                     rc = 0;
+
+        switch (common->data_dir) {
+        case DATA_DIR_NONE:
+                break;                  /* Nothing to send */
+
+        /* If we don't know whether the host wants to read or write,
+         * this must be CB or CBI with an unknown command.  We mustn't
+         * try to send or receive any data.  So stall both bulk pipes
+         * if we can and wait for a reset. */
+        case DATA_DIR_UNKNOWN:
+                if (!common->can_stall) {
+                        /* Nothing */
+                } else if (fsg_is_set(common)) {
+                        fsg_set_halt(common->fsg, common->fsg->bulk_out);
+                        rc = halt_bulk_in_endpoint(common->fsg);
+                } else {
+                        /* Don't know what to do if common->fsg is NULL */
+                        rc = -EIO;
+                }
+                break;
+
+        /* All but the last buffer of data must have already been sent */
+        case DATA_DIR_TO_HOST:
+                if (common->data_size == 0) {
+                        /* Nothing to send */
+
+                /* If there's no residue, simply send the last buffer */
+                } else if (common->residue == 0) {
+                        bh->inreq->zero = 0;
+                        START_TRANSFER_OR(common, bulk_in, bh->inreq,
+                                          &bh->inreq_busy, &bh->state)
+                                return -EIO;
+                        common->next_buffhd_to_fill = bh->next;
+
+                /* For Bulk-only, if we're allowed to stall then send the
+                 * short packet and halt the bulk-in endpoint.  If we can't
+                 * stall, pad out the remaining data with 0's. */
+                } else if (common->can_stall) {
+                        bh->inreq->zero = 1;
+                        START_TRANSFER_OR(common, bulk_in, bh->inreq,
+                                          &bh->inreq_busy, &bh->state)
+                                /* Don't know what to do if
+                                 * common->fsg is NULL */
+                                rc = -EIO;
+                        common->next_buffhd_to_fill = bh->next;
+                        if (common->fsg)
+                                rc = halt_bulk_in_endpoint(common->fsg);
+                } else if (fsg_is_set(common)) {
+                        rc = pad_with_zeros(common->fsg);
+                } else {
+                        /* Don't know what to do if common->fsg is NULL */
+                        rc = -EIO;
+                }
+                break;
+
+        /* We have processed all we want from the data the host has sent.
+         * There may still be outstanding bulk-out requests. */
+        case DATA_DIR_FROM_HOST:
+                if (common->residue == 0) {
+                        /* Nothing to receive */
+
+                /* Did the host stop sending unexpectedly early? */
+                } else if (common->short_packet_received) {
+                        raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
+                        rc = -EINTR;
+
+                /* We haven't processed all the incoming data.  Even though
+                 * we may be allowed to stall, doing so would cause a race.
+                 * The controller may already have ACK'ed all the remaining
+                 * bulk-out packets, in which case the host wouldn't see a
+                 * STALL.  Not realizing the endpoint was halted, it wouldn't
+                 * clear the halt -- leading to problems later on. */
+#if 0
+                } else if (common->can_stall) {
+                        if (fsg_is_set(common))
+                                fsg_set_halt(common->fsg,
+                                             common->fsg->bulk_out);
+                        raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
+                        rc = -EINTR;
+#endif
+
+                /* We can't stall.  Read in the excess data and throw it
+                 * all away. */
+                } else {
+                        rc = throw_away_data(common);
+                }
+                break;
+        }
+        return rc;
+}
+
+
+static int send_status(struct fsg_common *common)
+{
+        struct fsg_lun          *curlun = common->curlun;
+        struct fsg_buffhd       *bh;
+        struct bulk_cs_wrap     *csw;
+        int                     rc;
+        u8                      status = USB_STATUS_PASS;
+        u32                     sd, sdinfo = 0;
+
+        /* Wait for the next buffer to become available */
+        bh = common->next_buffhd_to_fill;
+        while (bh->state != BUF_STATE_EMPTY) {
+                rc = sleep_thread(common);
+                if (rc)
+                        return rc;
+        }
+
+        if (curlun) {
+                sd = curlun->sense_data;
+                sdinfo = curlun->sense_data_info;
+        } else if (common->bad_lun_okay)
+                sd = SS_NO_SENSE;
+        else
+                sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
+
+        if (common->phase_error) {
+                DBG(common, "sending phase-error status\n");
+                status = USB_STATUS_PHASE_ERROR;
+                sd = SS_INVALID_COMMAND;
+        } else if (sd != SS_NO_SENSE) {
+                DBG(common, "sending command-failure status\n");
+                status = USB_STATUS_FAIL;
+                VDBG(common, "  sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
+                                "  info x%x\n",
+                                SK(sd), ASC(sd), ASCQ(sd), sdinfo);
+        }
+
+        /* Store and send the Bulk-only CSW */
+        csw = (void *)bh->buf;
+
+        csw->Signature = cpu_to_le32(USB_BULK_CS_SIG);
+        csw->Tag = common->tag;
+        csw->Residue = cpu_to_le32(common->residue);
+        csw->Status = status;
+
+        bh->inreq->length = USB_BULK_CS_WRAP_LEN;
+        bh->inreq->zero = 0;
+        START_TRANSFER_OR(common, bulk_in, bh->inreq,
+                          &bh->inreq_busy, &bh->state)
+                /* Don't know what to do if common->fsg is NULL */
+                return -EIO;
+
+        common->next_buffhd_to_fill = bh->next;
+        return 0;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+/* Check whether the command is properly formed and whether its data size
+ * and direction agree with the values we already have. */
+static int check_command(struct fsg_common *common, int cmnd_size,
+                enum data_direction data_dir, unsigned int mask,
+                int needs_medium, const char *name)
+{
+        int                     i;
+        int                     lun = common->cmnd[1] >> 5;
+        static const char       dirletter[4] = {'u', 'o', 'i', 'n'};
+        char                    hdlen[20];
+        struct fsg_lun          *curlun;
+
+        hdlen[0] = 0;
+        if (common->data_dir != DATA_DIR_UNKNOWN)
+                sprintf(hdlen, ", H%c=%u", dirletter[(int) common->data_dir],
+                                common->data_size);
+        VDBG(common, "SCSI command: %s;  Dc=%d, D%c=%u;  Hc=%d%s\n",
+             name, cmnd_size, dirletter[(int) data_dir],
+             common->data_size_from_cmnd, common->cmnd_size, hdlen);
+
+        /* We can't reply at all until we know the correct data direction
+         * and size. */
+        if (common->data_size_from_cmnd == 0)
+                data_dir = DATA_DIR_NONE;
+        if (common->data_size < common->data_size_from_cmnd) {
+                /* Host data size < Device data size is a phase error.
+                 * Carry out the command, but only transfer as much as
+                 * we are allowed. */
+                common->data_size_from_cmnd = common->data_size;
+                common->phase_error = 1;
+        }
+        common->residue = common->data_size;
+        common->usb_amount_left = common->data_size;
+
+        /* Conflicting data directions is a phase error */
+        if (common->data_dir != data_dir
+         && common->data_size_from_cmnd > 0) {
+                common->phase_error = 1;
+                return -EINVAL;
+        }
+
+        /* Verify the length of the command itself */
+        if (cmnd_size != common->cmnd_size) {
+
+                /* Special case workaround: There are plenty of buggy SCSI
+                 * implementations. Many have issues with cbw->Length
+                 * field passing a wrong command size. For those cases we
+                 * always try to work around the problem by using the length
+                 * sent by the host side provided it is at least as large
+                 * as the correct command length.
+                 * Examples of such cases would be MS-Windows, which issues
+                 * REQUEST SENSE with cbw->Length == 12 where it should
+                 * be 6, and xbox360 issuing INQUIRY, TEST UNIT READY and
+                 * REQUEST SENSE with cbw->Length == 10 where it should
+                 * be 6 as well.
+                 */
+                if (cmnd_size <= common->cmnd_size) {
+                        DBG(common, "%s is buggy! Expected length %d "
+                            "but we got %d\n", name,
+                            cmnd_size, common->cmnd_size);
+                        cmnd_size = common->cmnd_size;
+                } else {
+                        common->phase_error = 1;
+                        return -EINVAL;
+                }
+        }
+
+        /* Check that the LUN values are consistent */
+        if (common->lun != lun)
+                DBG(common, "using LUN %d from CBW, not LUN %d from CDB\n",
+                    common->lun, lun);
+
+        /* Check the LUN */
+        if (common->lun >= 0 && common->lun < common->nluns) {
+                curlun = &common->luns[common->lun];
+                common->curlun = curlun;
+                if (common->cmnd[0] != SC_REQUEST_SENSE) {
+                        curlun->sense_data = SS_NO_SENSE;
+                        curlun->sense_data_info = 0;
+                        curlun->info_valid = 0;
+                }
+        } else {
+                common->curlun = NULL;
+                curlun = NULL;
+                common->bad_lun_okay = 0;
+
+                /* INQUIRY and REQUEST SENSE commands are explicitly allowed
+                 * to use unsupported LUNs; all others may not. */
+                if (common->cmnd[0] != SC_INQUIRY &&
+                    common->cmnd[0] != SC_REQUEST_SENSE) {
+                        DBG(common, "unsupported LUN %d\n", common->lun);
+                        return -EINVAL;
+                }
+        }
+
+        /* If a unit attention condition exists, only INQUIRY and
+         * REQUEST SENSE commands are allowed; anything else must fail. */
+        if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
+                        common->cmnd[0] != SC_INQUIRY &&
+                        common->cmnd[0] != SC_REQUEST_SENSE) {
+                curlun->sense_data = curlun->unit_attention_data;
+                curlun->unit_attention_data = SS_NO_SENSE;
+                return -EINVAL;
+        }
+
+        /* Check that only command bytes listed in the mask are non-zero */
+        common->cmnd[1] &= 0x1f;                        /* Mask away the LUN */
+        for (i = 1; i < cmnd_size; ++i) {
+                if (common->cmnd[i] && !(mask & (1 << i))) {
+                        if (curlun)
+                                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                        return -EINVAL;
+                }
+        }
+
+        /* If the medium isn't mounted and the command needs to access
+         * it, return an error. */
+        if (curlun && !fsg_lun_is_open(curlun) && needs_medium) {
+                curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+
+static int do_scsi_command(struct fsg_common *common)
+{
+        struct fsg_buffhd       *bh;
+        int                     rc;
+        int                     reply = -EINVAL;
+        int                     i;
+        static char             unknown[16];
+
+        dump_cdb(common);
+
+        /* Wait for the next buffer to become available for data or status */
+        bh = common->next_buffhd_to_fill;
+        common->next_buffhd_to_drain = bh;
+        while (bh->state != BUF_STATE_EMPTY) {
+                rc = sleep_thread(common);
+                if (rc)
+                        return rc;
+        }
+        common->phase_error = 0;
+        common->short_packet_received = 0;
+
+        down_read(&common->filesem);    /* We're using the backing file */
+        switch (common->cmnd[0]) {
+
+        case SC_INQUIRY:
+                common->data_size_from_cmnd = common->cmnd[4];
+                reply = check_command(common, 6, DATA_DIR_TO_HOST,
+                                      (1<<4), 0,
+                                      "INQUIRY");
+                if (reply == 0)
+                        reply = do_inquiry(common, bh);
+                break;
+
+        case SC_MODE_SELECT_6:
+                common->data_size_from_cmnd = common->cmnd[4];
+                reply = check_command(common, 6, DATA_DIR_FROM_HOST,
+                                      (1<<1) | (1<<4), 0,
+                                      "MODE SELECT(6)");
+                if (reply == 0)
+                        reply = do_mode_select(common, bh);
+                break;
+
+        case SC_MODE_SELECT_10:
+                common->data_size_from_cmnd =
+                        get_unaligned_be16(&common->cmnd[7]);
+                reply = check_command(common, 10, DATA_DIR_FROM_HOST,
+                                      (1<<1) | (3<<7), 0,
+                                      "MODE SELECT(10)");
+                if (reply == 0)
+                        reply = do_mode_select(common, bh);
+                break;
+
+        case SC_MODE_SENSE_6:
+                common->data_size_from_cmnd = common->cmnd[4];
+                reply = check_command(common, 6, DATA_DIR_TO_HOST,
+                                      (1<<1) | (1<<2) | (1<<4), 0,
+                                      "MODE SENSE(6)");
+                if (reply == 0)
+                        reply = do_mode_sense(common, bh);
+                break;
+
+        case SC_MODE_SENSE_10:
+                common->data_size_from_cmnd =
+                        get_unaligned_be16(&common->cmnd[7]);
+                reply = check_command(common, 10, DATA_DIR_TO_HOST,
+                                      (1<<1) | (1<<2) | (3<<7), 0,
+                                      "MODE SENSE(10)");
+                if (reply == 0)
+                        reply = do_mode_sense(common, bh);
+                break;
+
+        case SC_PREVENT_ALLOW_MEDIUM_REMOVAL:
+                common->data_size_from_cmnd = 0;
+                reply = check_command(common, 6, DATA_DIR_NONE,
+                                      (1<<4), 0,
+                                      "PREVENT-ALLOW MEDIUM REMOVAL");
+                if (reply == 0)
+                        reply = do_prevent_allow(common);
+                break;
+
+        case SC_READ_6:
+                i = common->cmnd[4];
+                common->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
+                reply = check_command(common, 6, DATA_DIR_TO_HOST,
+                                      (7<<1) | (1<<4), 1,
+                                      "READ(6)");
+                if (reply == 0)
+                        reply = do_read(common);
+                break;
+
+        case SC_READ_10:
+                common->data_size_from_cmnd =
+                                get_unaligned_be16(&common->cmnd[7]) << 9;
+                reply = check_command(common, 10, DATA_DIR_TO_HOST,
+                                      (1<<1) | (0xf<<2) | (3<<7), 1,
+                                      "READ(10)");
+                if (reply == 0)
+                        reply = do_read(common);
+                break;
+
+        case SC_READ_12:
+                common->data_size_from_cmnd =
+                                get_unaligned_be32(&common->cmnd[6]) << 9;
+                reply = check_command(common, 12, DATA_DIR_TO_HOST,
+                                      (1<<1) | (0xf<<2) | (0xf<<6), 1,
+                                      "READ(12)");
+                if (reply == 0)
+                        reply = do_read(common);
+                break;
+
+        case SC_READ_CAPACITY:
+                common->data_size_from_cmnd = 8;
+                reply = check_command(common, 10, DATA_DIR_TO_HOST,
+                                      (0xf<<2) | (1<<8), 1,
+                                      "READ CAPACITY");
+                if (reply == 0)
+                        reply = do_read_capacity(common, bh);
+                break;
+
+        case SC_READ_HEADER:
+                if (!common->curlun || !common->curlun->cdrom)
+                        goto unknown_cmnd;
+                common->data_size_from_cmnd =
+                        get_unaligned_be16(&common->cmnd[7]);
+                reply = check_command(common, 10, DATA_DIR_TO_HOST,
+                                      (3<<7) | (0x1f<<1), 1,
+                                      "READ HEADER");
+                if (reply == 0)
+                        reply = do_read_header(common, bh);
+                break;
+
+        case SC_READ_TOC:
+                if (!common->curlun || !common->curlun->cdrom)
+                        goto unknown_cmnd;
+                common->data_size_from_cmnd =
+                        get_unaligned_be16(&common->cmnd[7]);
+                reply = check_command(common, 10, DATA_DIR_TO_HOST,
+                                      (7<<6) | (1<<1), 1,
+                                      "READ TOC");
+                if (reply == 0)
+                        reply = do_read_toc(common, bh);
+                break;
+
+        case SC_READ_FORMAT_CAPACITIES:
+                common->data_size_from_cmnd =
+                        get_unaligned_be16(&common->cmnd[7]);
+                reply = check_command(common, 10, DATA_DIR_TO_HOST,
+                                      (3<<7), 1,
+                                      "READ FORMAT CAPACITIES");
+                if (reply == 0)
+                        reply = do_read_format_capacities(common, bh);
+                break;
+
+        case SC_REQUEST_SENSE:
+                common->data_size_from_cmnd = common->cmnd[4];
+                reply = check_command(common, 6, DATA_DIR_TO_HOST,
+                                      (1<<4), 0,
+                                      "REQUEST SENSE");
+                if (reply == 0)
+                        reply = do_request_sense(common, bh);
+                break;
+
+        case SC_START_STOP_UNIT:
+                common->data_size_from_cmnd = 0;
+                reply = check_command(common, 6, DATA_DIR_NONE,
+                                      (1<<1) | (1<<4), 0,
+                                      "START-STOP UNIT");
+                if (reply == 0)
+                        reply = do_start_stop(common);
+                break;
+
+        case SC_SYNCHRONIZE_CACHE:
+                common->data_size_from_cmnd = 0;
+                reply = check_command(common, 10, DATA_DIR_NONE,
+                                      (0xf<<2) | (3<<7), 1,
+                                      "SYNCHRONIZE CACHE");
+                if (reply == 0)
+                        reply = do_synchronize_cache(common);
+                break;
+
+        case SC_TEST_UNIT_READY:
+                common->data_size_from_cmnd = 0;
+                reply = check_command(common, 6, DATA_DIR_NONE,
+                                0, 1,
+                                "TEST UNIT READY");
+                break;
+
+        /* Although optional, this command is used by MS-Windows.  We
+         * support a minimal version: BytChk must be 0. */
+        case SC_VERIFY:
+                common->data_size_from_cmnd = 0;
+                reply = check_command(common, 10, DATA_DIR_NONE,
+                                      (1<<1) | (0xf<<2) | (3<<7), 1,
+                                      "VERIFY");
+                if (reply == 0)
+                        reply = do_verify(common);
+                break;
+
+        case SC_WRITE_6:
+                i = common->cmnd[4];
+                common->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
+                reply = check_command(common, 6, DATA_DIR_FROM_HOST,
+                                      (7<<1) | (1<<4), 1,
+                                      "WRITE(6)");
+                if (reply == 0)
+                        reply = do_write(common);
+                break;
+
+        case SC_WRITE_10:
+                common->data_size_from_cmnd =
+                                get_unaligned_be16(&common->cmnd[7]) << 9;
+                reply = check_command(common, 10, DATA_DIR_FROM_HOST,
+                                      (1<<1) | (0xf<<2) | (3<<7), 1,
+                                      "WRITE(10)");
+                if (reply == 0)
+                        reply = do_write(common);
+                break;
+
+        case SC_WRITE_12:
+                common->data_size_from_cmnd =
+                                get_unaligned_be32(&common->cmnd[6]) << 9;
+                reply = check_command(common, 12, DATA_DIR_FROM_HOST,
+                                      (1<<1) | (0xf<<2) | (0xf<<6), 1,
+                                      "WRITE(12)");
+                if (reply == 0)
+                        reply = do_write(common);
+                break;
+
+        /* Some mandatory commands that we recognize but don't implement.
+         * They don't mean much in this setting.  It's left as an exercise
+         * for anyone interested to implement RESERVE and RELEASE in terms
+         * of Posix locks. */
+        case SC_FORMAT_UNIT:
+        case SC_RELEASE:
+        case SC_RESERVE:
+        case SC_SEND_DIAGNOSTIC:
+                /* Fall through */
+
+        default:
+unknown_cmnd:
+                common->data_size_from_cmnd = 0;
+                sprintf(unknown, "Unknown x%02x", common->cmnd[0]);
+                reply = check_command(common, common->cmnd_size,
+                                      DATA_DIR_UNKNOWN, 0xff, 0, unknown);
+                if (reply == 0) {
+                        common->curlun->sense_data = SS_INVALID_COMMAND;
+                        reply = -EINVAL;
+                }
+                break;
+        }
+        up_read(&common->filesem);
+
+        if (reply == -EINTR || signal_pending(current))
+                return -EINTR;
+
+        /* Set up the single reply buffer for finish_reply() */
+        if (reply == -EINVAL)
+                reply = 0;              /* Error reply length */
+        if (reply >= 0 && common->data_dir == DATA_DIR_TO_HOST) {
+                reply = min((u32) reply, common->data_size_from_cmnd);
+                bh->inreq->length = reply;
+                bh->state = BUF_STATE_FULL;
+                common->residue -= reply;
+        }                               /* Otherwise it's already set */
+
+        return 0;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
+{
+        struct usb_request      *req = bh->outreq;
+        struct fsg_bulk_cb_wrap *cbw = req->buf;
+        struct fsg_common       *common = fsg->common;
+
+        /* Was this a real packet?  Should it be ignored? */
+        if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
+                return -EINVAL;
+
+        /* Is the CBW valid? */
+        if (req->actual != USB_BULK_CB_WRAP_LEN ||
+                        cbw->Signature != cpu_to_le32(
+                                USB_BULK_CB_SIG)) {
+                DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
+                                req->actual,
+                                le32_to_cpu(cbw->Signature));
+
+                /* The Bulk-only spec says we MUST stall the IN endpoint
+                 * (6.6.1), so it's unavoidable.  It also says we must
+                 * retain this state until the next reset, but there's
+                 * no way to tell the controller driver it should ignore
+                 * Clear-Feature(HALT) requests.
+                 *
+                 * We aren't required to halt the OUT endpoint; instead
+                 * we can simply accept and discard any data received
+                 * until the next reset. */
+                wedge_bulk_in_endpoint(fsg);
+                set_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
+                return -EINVAL;
+        }
+
+        /* Is the CBW meaningful? */
+        if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
+                        cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
+                DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
+                                "cmdlen %u\n",
+                                cbw->Lun, cbw->Flags, cbw->Length);
+
+                /* We can do anything we want here, so let's stall the
+                 * bulk pipes if we are allowed to. */
+                if (common->can_stall) {
+                        fsg_set_halt(fsg, fsg->bulk_out);
+                        halt_bulk_in_endpoint(fsg);
+                }
+                return -EINVAL;
+        }
+
+        /* Save the command for later */
+        common->cmnd_size = cbw->Length;
+        memcpy(common->cmnd, cbw->CDB, common->cmnd_size);
+        if (cbw->Flags & USB_BULK_IN_FLAG)
+                common->data_dir = DATA_DIR_TO_HOST;
+        else
+                common->data_dir = DATA_DIR_FROM_HOST;
+        common->data_size = le32_to_cpu(cbw->DataTransferLength);
+        if (common->data_size == 0)
+                common->data_dir = DATA_DIR_NONE;
+        common->lun = cbw->Lun;
+        common->tag = cbw->Tag;
+        return 0;
+}
+
+
+static int get_next_command(struct fsg_common *common)
+{
+        struct fsg_buffhd       *bh;
+        int                     rc = 0;
+
+        /* Wait for the next buffer to become available */
+        bh = common->next_buffhd_to_fill;
+        while (bh->state != BUF_STATE_EMPTY) {
+                rc = sleep_thread(common);
+                if (rc)
+                        return rc;
+        }
+
+        /* Queue a request to read a Bulk-only CBW */
+        set_bulk_out_req_length(common, bh, USB_BULK_CB_WRAP_LEN);
+        bh->outreq->short_not_ok = 1;
+        START_TRANSFER_OR(common, bulk_out, bh->outreq,
+                          &bh->outreq_busy, &bh->state)
+                /* Don't know what to do if common->fsg is NULL */
+                return -EIO;
+
+        /* We will drain the buffer in software, which means we
+         * can reuse it for the next filling.  No need to advance
+         * next_buffhd_to_fill. */
+
+        /* Wait for the CBW to arrive */
+        while (bh->state != BUF_STATE_FULL) {
+                rc = sleep_thread(common);
+                if (rc)
+                        return rc;
+        }
+        smp_rmb();
+        rc = fsg_is_set(common) ? received_cbw(common->fsg, bh) : -EIO;
+        bh->state = BUF_STATE_EMPTY;
+
+        return rc;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int enable_endpoint(struct fsg_common *common, struct usb_ep *ep,
+                const struct usb_endpoint_descriptor *d)
+{
+        int     rc;
+
+        ep->driver_data = common;
+        rc = usb_ep_enable(ep, d);
+        if (rc)
+                ERROR(common, "can't enable %s, result %d\n", ep->name, rc);
+        return rc;
+}
+
+static int alloc_request(struct fsg_common *common, struct usb_ep *ep,
+                struct usb_request **preq)
+{
+        *preq = usb_ep_alloc_request(ep, GFP_ATOMIC);
+        if (*preq)
+                return 0;
+        ERROR(common, "can't allocate request for %s\n", ep->name);
+        return -ENOMEM;
+}
+
+/*
+ * Reset interface setting and re-init endpoint state (toggle etc).
+ * Call with altsetting < 0 to disable the interface.  The only other
+ * available altsetting is 0, which enables the interface.
+ */
+static int do_set_interface(struct fsg_common *common, int altsetting)
+{
+        int     rc = 0;
+        int     i;
+        const struct usb_endpoint_descriptor    *d;
+
+        if (common->running)
+                DBG(common, "reset interface\n");
+
+reset:
+        /* Deallocate the requests */
+        if (common->prev_fsg) {
+                struct fsg_dev *fsg = common->prev_fsg;
+
+                for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
+                        struct fsg_buffhd *bh = &common->buffhds[i];
+
+                        if (bh->inreq) {
+                                usb_ep_free_request(fsg->bulk_in, bh->inreq);
+                                bh->inreq = NULL;
+                        }
+                        if (bh->outreq) {
+                                usb_ep_free_request(fsg->bulk_out, bh->outreq);
+                                bh->outreq = NULL;
+                        }
+                }
+
+                /* Disable the endpoints */
+                if (fsg->bulk_in_enabled) {
+                        usb_ep_disable(fsg->bulk_in);
+                        fsg->bulk_in_enabled = 0;
+                }
+                if (fsg->bulk_out_enabled) {
+                        usb_ep_disable(fsg->bulk_out);
+                        fsg->bulk_out_enabled = 0;
+                }
+
+                common->prev_fsg = 0;
+        }
+
+        common->running = 0;
+        if (altsetting < 0 || rc != 0)
+                return rc;
+
+        DBG(common, "set interface %d\n", altsetting);
+
+        if (fsg_is_set(common)) {
+                struct fsg_dev *fsg = common->fsg;
+                common->prev_fsg = common->fsg;
+
+                /* Enable the endpoints */
+                d = fsg_ep_desc(common->gadget,
+                                &fsg_fs_bulk_in_desc, &fsg_hs_bulk_in_desc);
+                rc = enable_endpoint(common, fsg->bulk_in, d);
+                if (rc)
+                        goto reset;
+                fsg->bulk_in_enabled = 1;
+
+                d = fsg_ep_desc(common->gadget,
+                                &fsg_fs_bulk_out_desc, &fsg_hs_bulk_out_desc);
+                rc = enable_endpoint(common, fsg->bulk_out, d);
+                if (rc)
+                        goto reset;
+                fsg->bulk_out_enabled = 1;
+                common->bulk_out_maxpacket = le16_to_cpu(d->wMaxPacketSize);
+                clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
+
+                /* Allocate the requests */
+                for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
+                        struct fsg_buffhd       *bh = &common->buffhds[i];
+
+                        rc = alloc_request(common, fsg->bulk_in, &bh->inreq);
+                        if (rc)
+                                goto reset;
+                        rc = alloc_request(common, fsg->bulk_out, &bh->outreq);
+                        if (rc)
+                                goto reset;
+                        bh->inreq->buf = bh->outreq->buf = bh->buf;
+                        bh->inreq->context = bh->outreq->context = bh;
+                        bh->inreq->complete = bulk_in_complete;
+                        bh->outreq->complete = bulk_out_complete;
+                }
+
+                common->running = 1;
+                for (i = 0; i < common->nluns; ++i)
+                        common->luns[i].unit_attention_data = SS_RESET_OCCURRED;
+                return rc;
+        } else {
+                return -EIO;
+        }
+}
+
+
+/*
+ * Change our operational configuration.  This code must agree with the code
+ * that returns config descriptors, and with interface altsetting code.
+ *
+ * It's also responsible for power management interactions.  Some
+ * configurations might not work with our current power sources.
+ * For now we just assume the gadget is always self-powered.
+ */
+static int do_set_config(struct fsg_common *common, u8 new_config)
+{
+        int     rc = 0;
+
+        /* Disable the single interface */
+        if (common->config != 0) {
+                DBG(common, "reset config\n");
+                common->config = 0;
+                rc = do_set_interface(common, -1);
+        }
+
+        /* Enable the interface */
+        if (new_config != 0) {
+                common->config = new_config;
+                rc = do_set_interface(common, 0);
+                if (rc != 0)
+                        common->config = 0;     /* Reset on errors */
+        }
+        return rc;
+}
+
+
+/****************************** ALT CONFIGS ******************************/
+
+
+static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+        struct fsg_dev *fsg = fsg_from_func(f);
+        fsg->common->prev_fsg = fsg->common->fsg;
+        fsg->common->fsg = fsg;
+        fsg->common->new_config = 1;
+        raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
+        return 0;
+}
+
+static void fsg_disable(struct usb_function *f)
+{
+        struct fsg_dev *fsg = fsg_from_func(f);
+        fsg->common->prev_fsg = fsg->common->fsg;
+        fsg->common->fsg = fsg;
+        fsg->common->new_config = 0;
+        raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static void handle_exception(struct fsg_common *common)
+{
+        siginfo_t               info;
+        int                     sig;
+        int                     i;
+        struct fsg_buffhd       *bh;
+        enum fsg_state          old_state;
+        u8                      new_config;
+        struct fsg_lun          *curlun;
+        unsigned int            exception_req_tag;
+        int                     rc;
+
+        /* Clear the existing signals.  Anything but SIGUSR1 is converted
+         * into a high-priority EXIT exception. */
+        for (;;) {
+                sig = dequeue_signal_lock(current, &current->blocked, &info);
+                if (!sig)
+                        break;
+                if (sig != SIGUSR1) {
+                        if (common->state < FSG_STATE_EXIT)
+                                DBG(common, "Main thread exiting on signal\n");
+                        raise_exception(common, FSG_STATE_EXIT);
+                }
+        }
+
+        /* Cancel all the pending transfers */
+        if (fsg_is_set(common)) {
+                for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
+                        bh = &common->buffhds[i];
+                        if (bh->inreq_busy)
+                                usb_ep_dequeue(common->fsg->bulk_in, bh->inreq);
+                        if (bh->outreq_busy)
+                                usb_ep_dequeue(common->fsg->bulk_out,
+                                               bh->outreq);
+                }
+
+                /* Wait until everything is idle */
+                for (;;) {
+                        int num_active = 0;
+                        for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
+                                bh = &common->buffhds[i];
+                                num_active += bh->inreq_busy + bh->outreq_busy;
+                        }
+                        if (num_active == 0)
+                                break;
+                        if (sleep_thread(common))
+                                return;
+                }
+
+                /* Clear out the controller's fifos */
+                if (common->fsg->bulk_in_enabled)
+                        usb_ep_fifo_flush(common->fsg->bulk_in);
+                if (common->fsg->bulk_out_enabled)
+                        usb_ep_fifo_flush(common->fsg->bulk_out);
+        }
+
+        /* Reset the I/O buffer states and pointers, the SCSI
+         * state, and the exception.  Then invoke the handler. */
+        spin_lock_irq(&common->lock);
+
+        for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
+                bh = &common->buffhds[i];
+                bh->state = BUF_STATE_EMPTY;
+        }
+        common->next_buffhd_to_fill = &common->buffhds[0];
+        common->next_buffhd_to_drain = &common->buffhds[0];
+        exception_req_tag = common->exception_req_tag;
+        new_config = common->new_config;
+        old_state = common->state;
+
+        if (old_state == FSG_STATE_ABORT_BULK_OUT)
+                common->state = FSG_STATE_STATUS_PHASE;
+        else {
+                for (i = 0; i < common->nluns; ++i) {
+                        curlun = &common->luns[i];
+                        curlun->prevent_medium_removal = 0;
+                        curlun->sense_data = SS_NO_SENSE;
+                        curlun->unit_attention_data = SS_NO_SENSE;
+                        curlun->sense_data_info = 0;
+                        curlun->info_valid = 0;
+                }
+                common->state = FSG_STATE_IDLE;
+        }
+        spin_unlock_irq(&common->lock);
+
+        /* Carry out any extra actions required for the exception */
+        switch (old_state) {
+        case FSG_STATE_ABORT_BULK_OUT:
+                send_status(common);
+                spin_lock_irq(&common->lock);
+                if (common->state == FSG_STATE_STATUS_PHASE)
+                        common->state = FSG_STATE_IDLE;
+                spin_unlock_irq(&common->lock);
+                break;
+
+        case FSG_STATE_RESET:
+                /* In case we were forced against our will to halt a
+                 * bulk endpoint, clear the halt now.  (The SuperH UDC
+                 * requires this.) */
+                if (!fsg_is_set(common))
+                        break;
+                if (test_and_clear_bit(IGNORE_BULK_OUT,
+                                       &common->fsg->atomic_bitflags))
+                        usb_ep_clear_halt(common->fsg->bulk_in);
+
+                if (common->ep0_req_tag == exception_req_tag)
+                        ep0_queue(common);      /* Complete the status stage */
+
+                /* Technically this should go here, but it would only be
+                 * a waste of time.  Ditto for the INTERFACE_CHANGE and
+                 * CONFIG_CHANGE cases. */
+                /* for (i = 0; i < common->nluns; ++i) */
+                /*      common->luns[i].unit_attention_data = */
+                /*              SS_RESET_OCCURRED;  */
+                break;
+
+        case FSG_STATE_CONFIG_CHANGE:
+                rc = do_set_config(common, new_config);
+                break;
+
+        case FSG_STATE_EXIT:
+        case FSG_STATE_TERMINATED:
+                do_set_config(common, 0);               /* Free resources */
+                spin_lock_irq(&common->lock);
+                common->state = FSG_STATE_TERMINATED;   /* Stop the thread */
+                spin_unlock_irq(&common->lock);
+                break;
+
+        case FSG_STATE_INTERFACE_CHANGE:
+        case FSG_STATE_DISCONNECT:
+        case FSG_STATE_COMMAND_PHASE:
+        case FSG_STATE_DATA_PHASE:
+        case FSG_STATE_STATUS_PHASE:
+        case FSG_STATE_IDLE:
+                break;
+        }
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int fsg_main_thread(void *common_)
+{
+        struct fsg_common       *common = common_;
+
+        /* Allow the thread to be killed by a signal, but set the signal mask
+         * to block everything but INT, TERM, KILL, and USR1. */
+        allow_signal(SIGINT);
+        allow_signal(SIGTERM);
+        allow_signal(SIGKILL);
+        allow_signal(SIGUSR1);
+
+        /* Allow the thread to be frozen */
+        set_freezable();
+
+        /* Arrange for userspace references to be interpreted as kernel
+         * pointers.  That way we can pass a kernel pointer to a routine
+         * that expects a __user pointer and it will work okay. */
+        set_fs(get_ds());
+
+        /* The main loop */
+        while (common->state != FSG_STATE_TERMINATED) {
+                if (exception_in_progress(common) || signal_pending(current)) {
+                        handle_exception(common);
+                        continue;
+                }
+
+                if (!common->running) {
+                        sleep_thread(common);
+                        continue;
+                }
+
+                if (get_next_command(common))
+                        continue;
+
+                spin_lock_irq(&common->lock);
+                if (!exception_in_progress(common))
+                        common->state = FSG_STATE_DATA_PHASE;
+                spin_unlock_irq(&common->lock);
+
+                if (do_scsi_command(common) || finish_reply(common))
+                        continue;
+
+                spin_lock_irq(&common->lock);
+                if (!exception_in_progress(common))
+                        common->state = FSG_STATE_STATUS_PHASE;
+                spin_unlock_irq(&common->lock);
+
+                if (send_status(common))
+                        continue;
+
+                spin_lock_irq(&common->lock);
+                if (!exception_in_progress(common))
+                        common->state = FSG_STATE_IDLE;
+                spin_unlock_irq(&common->lock);
+        }
+
+        spin_lock_irq(&common->lock);
+        common->thread_task = NULL;
+        spin_unlock_irq(&common->lock);
+
+        if (!common->thread_exits || common->thread_exits(common) < 0) {
+                struct fsg_lun *curlun = common->luns;
+                unsigned i = common->nluns;
+
+                down_write(&common->filesem);
+                for (; i--; ++curlun) {
+                        if (!fsg_lun_is_open(curlun))
+                                continue;
+
+                        fsg_lun_close(curlun);
+                        curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
+                }
+                up_write(&common->filesem);
+        }
+
+        /* Let the unbind and cleanup routines know the thread has exited */
+        complete_and_exit(&common->thread_notifier, 0);
+}
+
+
+/*************************** DEVICE ATTRIBUTES ***************************/
+
+/* Write permission is checked per LUN in store_*() functions. */
+static DEVICE_ATTR(ro, 0644, fsg_show_ro, fsg_store_ro);
+static DEVICE_ATTR(file, 0644, fsg_show_file, fsg_store_file);
+
+
+/****************************** FSG COMMON ******************************/
+
+static void fsg_common_release(struct kref *ref);
+
+static void fsg_lun_release(struct device *dev)
+{
+        /* Nothing needs to be done */
+}
+
+static inline void fsg_common_get(struct fsg_common *common)
+{
+        kref_get(&common->ref);
+}
+
+static inline void fsg_common_put(struct fsg_common *common)
+{
+        kref_put(&common->ref, fsg_common_release);
+}
+
+
+static struct fsg_common *fsg_common_init(struct fsg_common *common,
+                                          struct usb_composite_dev *cdev,
+                                          struct fsg_config *cfg)
+{
+        struct usb_gadget *gadget = cdev->gadget;
+        struct fsg_buffhd *bh;
+        struct fsg_lun *curlun;
+        struct fsg_lun_config *lcfg;
+        int nluns, i, rc;
+        char *pathbuf;
+
+        /* Find out how many LUNs there should be */
+        nluns = cfg->nluns;
+        if (nluns < 1 || nluns > FSG_MAX_LUNS) {
+                dev_err(&gadget->dev, "invalid number of LUNs: %u\n", nluns);
+                return ERR_PTR(-EINVAL);
+        }
+
+        /* Allocate? */
+        if (!common) {
+                common = kzalloc(sizeof *common, GFP_KERNEL);
+                if (!common)
+                        return ERR_PTR(-ENOMEM);
+                common->free_storage_on_release = 1;
+        } else {
+                memset(common, 0, sizeof common);
+                common->free_storage_on_release = 0;
+        }
+
+        common->private_data = cfg->private_data;
+
+        common->gadget = gadget;
+        common->ep0 = gadget->ep0;
+        common->ep0req = cdev->req;
+
+        /* Maybe allocate device-global string IDs, and patch descriptors */
+        if (fsg_strings[FSG_STRING_INTERFACE].id == 0) {
+                rc = usb_string_id(cdev);
+                if (rc < 0) {
+                        kfree(common);
+                        return ERR_PTR(rc);
+                }
+                fsg_strings[FSG_STRING_INTERFACE].id = rc;
+                fsg_intf_desc.iInterface = rc;
+        }
+
+        /* Create the LUNs, open their backing files, and register the
+         * LUN devices in sysfs. */
+        curlun = kzalloc(nluns * sizeof *curlun, GFP_KERNEL);
+        if (!curlun) {
+                kfree(common);
+                return ERR_PTR(-ENOMEM);
+        }
+        common->luns = curlun;
+
+        init_rwsem(&common->filesem);
+
+        for (i = 0, lcfg = cfg->luns; i < nluns; ++i, ++curlun, ++lcfg) {
+                curlun->cdrom = !!lcfg->cdrom;
+                curlun->ro = lcfg->cdrom || lcfg->ro;
+                curlun->removable = lcfg->removable;
+                curlun->dev.release = fsg_lun_release;
+                curlun->dev.parent = &gadget->dev;
+                /* curlun->dev.driver = &fsg_driver.driver; XXX */
+                dev_set_drvdata(&curlun->dev, &common->filesem);
+                dev_set_name(&curlun->dev,
+                             cfg->lun_name_format
+                           ? cfg->lun_name_format
+                           : "lun%d",
+                             i);
+
+                rc = device_register(&curlun->dev);
+                if (rc) {
+                        INFO(common, "failed to register LUN%d: %d\n", i, rc);
+                        common->nluns = i;
+                        goto error_release;
+                }
+
+                rc = device_create_file(&curlun->dev, &dev_attr_ro);
+                if (rc)
+                        goto error_luns;
+                rc = device_create_file(&curlun->dev, &dev_attr_file);
+                if (rc)
+                        goto error_luns;
+
+                if (lcfg->filename) {
+                        rc = fsg_lun_open(curlun, lcfg->filename);
+                        if (rc)
+                                goto error_luns;
+                } else if (!curlun->removable) {
+                        ERROR(common, "no file given for LUN%d\n", i);
+                        rc = -EINVAL;
+                        goto error_luns;
+                }
+        }
+        common->nluns = nluns;
+
+
+        /* Data buffers cyclic list */
+        /* Buffers in buffhds are static -- no need for additional
+         * allocation. */
+        bh = common->buffhds;
+        i = FSG_NUM_BUFFERS - 1;
+        do {
+                bh->next = bh + 1;
+        } while (++bh, --i);
+        bh->next = common->buffhds;
+
+
+        /* Prepare inquiryString */
+        if (cfg->release != 0xffff) {
+                i = cfg->release;
+        } else {
+                i = usb_gadget_controller_number(gadget);
+                if (i >= 0) {
+                        i = 0x0300 + i;
+                } else {
+                        WARNING(common, "controller '%s' not recognized\n",
+                                gadget->name);
+                        i = 0x0399;
+                }
+        }
+#define OR(x, y) ((x) ? (x) : (y))
+        snprintf(common->inquiry_string, sizeof common->inquiry_string,
+                 "%-8s%-16s%04x",
+                 OR(cfg->vendor_name, "Linux   "),
+                 /* Assume product name dependent on the first LUN */
+                 OR(cfg->product_name, common->luns->cdrom
+                                     ? "File-Stor Gadget"
+                                     : "File-CD Gadget  "),
+                 i);
+
+
+        /* Some peripheral controllers are known not to be able to
+         * halt bulk endpoints correctly.  If one of them is present,
+         * disable stalls.
+         */
+        common->can_stall = cfg->can_stall &&
+                !(gadget_is_at91(common->gadget));
+
+
+        spin_lock_init(&common->lock);
+        kref_init(&common->ref);
+
+
+        /* Tell the thread to start working */
+        common->thread_exits = cfg->thread_exits;
+        common->thread_task =
+                kthread_create(fsg_main_thread, common,
+                               OR(cfg->thread_name, "file-storage"));
+        if (IS_ERR(common->thread_task)) {
+                rc = PTR_ERR(common->thread_task);
+                goto error_release;
+        }
+        init_completion(&common->thread_notifier);
+#undef OR
+
+
+        /* Information */
+        INFO(common, FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n");
+        INFO(common, "Number of LUNs=%d\n", common->nluns);
+
+        pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
+        for (i = 0, nluns = common->nluns, curlun = common->luns;
+             i < nluns;
+             ++curlun, ++i) {
+                char *p = "(no medium)";
+                if (fsg_lun_is_open(curlun)) {
+                        p = "(error)";
+                        if (pathbuf) {
+                                p = d_path(&curlun->filp->f_path,
+                                           pathbuf, PATH_MAX);
+                                if (IS_ERR(p))
+                                        p = "(error)";
+                        }
+                }
+                LINFO(curlun, "LUN: %s%s%sfile: %s\n",
+                      curlun->removable ? "removable " : "",
+                      curlun->ro ? "read only " : "",
+                      curlun->cdrom ? "CD-ROM " : "",
+                      p);
+        }
+        kfree(pathbuf);
+
+        DBG(common, "I/O thread pid: %d\n", task_pid_nr(common->thread_task));
+
+        wake_up_process(common->thread_task);
+
+        return common;
+
+
+error_luns:
+        common->nluns = i + 1;
+error_release:
+        common->state = FSG_STATE_TERMINATED;   /* The thread is dead */
+        /* Call fsg_common_release() directly, ref might be not
+         * initialised */
+        fsg_common_release(&common->ref);
+        return ERR_PTR(rc);
+}
+
+
+static void fsg_common_release(struct kref *ref)
+{
+        struct fsg_common *common =
+                container_of(ref, struct fsg_common, ref);
+        unsigned i = common->nluns;
+        struct fsg_lun *lun = common->luns;
+
+        /* If the thread isn't already dead, tell it to exit now */
+        if (common->state != FSG_STATE_TERMINATED) {
+                raise_exception(common, FSG_STATE_EXIT);
+                wait_for_completion(&common->thread_notifier);
+
+                /* The cleanup routine waits for this completion also */
+                complete(&common->thread_notifier);
+        }
+
+        /* Beware tempting for -> do-while optimization: when in error
+         * recovery nluns may be zero. */
+
+        for (; i; --i, ++lun) {
+                device_remove_file(&lun->dev, &dev_attr_ro);
+                device_remove_file(&lun->dev, &dev_attr_file);
+                fsg_lun_close(lun);
+                device_unregister(&lun->dev);
+        }
+
+        kfree(common->luns);
+        if (common->free_storage_on_release)
+                kfree(common);
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+
+static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct fsg_dev          *fsg = fsg_from_func(f);
+
+        DBG(fsg, "unbind\n");
+        fsg_common_put(fsg->common);
+        kfree(fsg);
+}
+
+
+static int __init fsg_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct fsg_dev          *fsg = fsg_from_func(f);
+        struct usb_gadget       *gadget = c->cdev->gadget;
+        int                     rc;
+        int                     i;
+        struct usb_ep           *ep;
+
+        fsg->gadget = gadget;
+
+        /* New interface */
+        i = usb_interface_id(c, f);
+        if (i < 0)
+                return i;
+        fsg_intf_desc.bInterfaceNumber = i;
+        fsg->interface_number = i;
+
+        /* Find all the endpoints we will use */
+        ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_in_desc);
+        if (!ep)
+                goto autoconf_fail;
+        ep->driver_data = fsg->common;  /* claim the endpoint */
+        fsg->bulk_in = ep;
+
+        ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_out_desc);
+        if (!ep)
+                goto autoconf_fail;
+        ep->driver_data = fsg->common;  /* claim the endpoint */
+        fsg->bulk_out = ep;
+
+        if (gadget_is_dualspeed(gadget)) {
+                /* Assume endpoint addresses are the same for both speeds */
+                fsg_hs_bulk_in_desc.bEndpointAddress =
+                        fsg_fs_bulk_in_desc.bEndpointAddress;
+                fsg_hs_bulk_out_desc.bEndpointAddress =
+                        fsg_fs_bulk_out_desc.bEndpointAddress;
+                f->hs_descriptors = fsg_hs_function;
+        }
+
+        return 0;
+
+autoconf_fail:
+        ERROR(fsg, "unable to autoconfigure all endpoints\n");
+        rc = -ENOTSUPP;
+        return rc;
+}
+
+
+/****************************** ADD FUNCTION ******************************/
+
+static struct usb_gadget_strings *fsg_strings_array[] = {
+        &fsg_stringtab,
+        NULL,
+};
+
+static int fsg_add(struct usb_composite_dev *cdev,
+                   struct usb_configuration *c,
+                   struct fsg_common *common)
+{
+        struct fsg_dev *fsg;
+        int rc;
+
+        fsg = kzalloc(sizeof *fsg, GFP_KERNEL);
+        if (unlikely(!fsg))
+                return -ENOMEM;
+
+        fsg->function.name        = FSG_DRIVER_DESC;
+        fsg->function.strings     = fsg_strings_array;
+        fsg->function.descriptors = fsg_fs_function;
+        fsg->function.bind        = fsg_bind;
+        fsg->function.unbind      = fsg_unbind;
+        fsg->function.setup       = fsg_setup;
+        fsg->function.set_alt     = fsg_set_alt;
+        fsg->function.disable     = fsg_disable;
+
+        fsg->common               = common;
+        /* Our caller holds a reference to common structure so we
+         * don't have to be worry about it being freed until we return
+         * from this function.  So instead of incrementing counter now
+         * and decrement in error recovery we increment it only when
+         * call to usb_add_function() was successful. */
+
+        rc = usb_add_function(c, &fsg->function);
+
+        if (likely(rc == 0))
+                fsg_common_get(fsg->common);
+        else
+                kfree(fsg);
+
+        return rc;
+}
+
+
+
+/************************* Module parameters *************************/
+
+
+struct fsg_module_parameters {
+        char            *file[FSG_MAX_LUNS];
+        int             ro[FSG_MAX_LUNS];
+        int             removable[FSG_MAX_LUNS];
+        int             cdrom[FSG_MAX_LUNS];
+
+        unsigned int    file_count, ro_count, removable_count, cdrom_count;
+        unsigned int    luns;   /* nluns */
+        int             stall;  /* can_stall */
+};
+
+
+#define _FSG_MODULE_PARAM_ARRAY(prefix, params, name, type, desc)       \
+        module_param_array_named(prefix ## name, params.name, type,     \
+                                 &prefix ## params.name ## _count,      \
+                                 S_IRUGO);                              \
+        MODULE_PARM_DESC(prefix ## name, desc)
+
+#define _FSG_MODULE_PARAM(prefix, params, name, type, desc)             \
+        module_param_named(prefix ## name, params.name, type,           \
+                           S_IRUGO);                                    \
+        MODULE_PARM_DESC(prefix ## name, desc)
+
+#define FSG_MODULE_PARAMETERS(prefix, params)                           \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, file, charp,            \
+                                "names of backing files or devices");   \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, ro, bool,               \
+                                "true to force read-only");             \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, removable, bool,        \
+                                "true to simulate removable media");    \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, cdrom, bool,            \
+                                "true to simulate CD-ROM instead of disk"); \
+        _FSG_MODULE_PARAM(prefix, params, luns, uint,                   \
+                          "number of LUNs");                            \
+        _FSG_MODULE_PARAM(prefix, params, stall, bool,                  \
+                          "false to prevent bulk stalls")
+
+
+static void
+fsg_config_from_params(struct fsg_config *cfg,
+                       const struct fsg_module_parameters *params)
+{
+        struct fsg_lun_config *lun;
+        unsigned i;
+
+        /* Configure LUNs */
+        cfg->nluns =
+                min(params->luns ?: (params->file_count ?: 1u),
+                    (unsigned)FSG_MAX_LUNS);
+        for (i = 0, lun = cfg->luns; i < cfg->nluns; ++i, ++lun) {
+                lun->ro = !!params->ro[i];
+                lun->cdrom = !!params->cdrom[i];
+                lun->removable = /* Removable by default */
+                        params->removable_count <= i || params->removable[i];
+                lun->filename =
+                        params->file_count > i && params->file[i][0]
+                        ? params->file[i]
+                        : 0;
+        }
+
+        /* Let MSF use defaults */
+        cfg->lun_name_format = 0;
+        cfg->thread_name = 0;
+        cfg->vendor_name = 0;
+        cfg->product_name = 0;
+        cfg->release = 0xffff;
+
+        cfg->thread_exits = 0;
+        cfg->private_data = 0;
+
+        /* Finalise */
+        cfg->can_stall = params->stall;
+}
+
+static inline struct fsg_common *
+fsg_common_from_params(struct fsg_common *common,
+                       struct usb_composite_dev *cdev,
+                       const struct fsg_module_parameters *params)
+        __attribute__((unused));
+static inline struct fsg_common *
+fsg_common_from_params(struct fsg_common *common,
+                       struct usb_composite_dev *cdev,
+                       const struct fsg_module_parameters *params)
+{
+        struct fsg_config cfg;
+        fsg_config_from_params(&cfg, params);
+        return fsg_common_init(common, cdev, &cfg);
+}
+
diff --git a/drivers/usb/gadget/f_obex.c b/drivers/usb/gadget/f_obex.c
index b4a3ba654ea5..8f8c64371475 100644
--- a/drivers/usb/gadget/f_obex.c
+++ b/drivers/usb/gadget/f_obex.c
@@ -23,6 +23,7 @@
 
 /* #define VERBOSE_DEBUG */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 
diff --git a/drivers/usb/gadget/f_phonet.c b/drivers/usb/gadget/f_phonet.c
index d2de10b9dc4b..3c6e1a058745 100644
--- a/drivers/usb/gadget/f_phonet.c
+++ b/drivers/usb/gadget/f_phonet.c
@@ -20,6 +20,7 @@
  * 02110-1301 USA
  */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index c9966cc07d3a..56b022150f22 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -4,6 +4,8 @@
  * Copyright (C) 2003-2005,2008 David Brownell
  * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
  * Copyright (C) 2008 Nokia Corporation
+ * Copyright (C) 2009 Samsung Electronics
+ *                    Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,6 +24,7 @@
 
 /* #define VERBOSE_DEBUG */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <linux/etherdevice.h>
@@ -149,8 +152,8 @@ static struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor __initdata = {
         .bDataInterface =       0x01,
 };
 
-static struct usb_cdc_acm_descriptor acm_descriptor __initdata = {
-        .bLength =              sizeof acm_descriptor,
+static struct usb_cdc_acm_descriptor rndis_acm_descriptor __initdata = {
+        .bLength =              sizeof rndis_acm_descriptor,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubType =   USB_CDC_ACM_TYPE,
 
@@ -179,6 +182,20 @@ static struct usb_interface_descriptor rndis_data_intf __initdata = {
         /* .iInterface = DYNAMIC */
 };
 
+
+static struct usb_interface_assoc_descriptor
+rndis_iad_descriptor = {
+        .bLength =              sizeof rndis_iad_descriptor,
+        .bDescriptorType =      USB_DT_INTERFACE_ASSOCIATION,
+
+        .bFirstInterface =      0, /* XXX, hardcoded */
+        .bInterfaceCount =      2,      // control + data
+        .bFunctionClass =       USB_CLASS_COMM,
+        .bFunctionSubClass =    USB_CDC_SUBCLASS_ETHERNET,
+        .bFunctionProtocol =    USB_CDC_PROTO_NONE,
+        /* .iFunction = DYNAMIC */
+};
+
 /* full speed support: */
 
 static struct usb_endpoint_descriptor fs_notify_desc __initdata = {
@@ -208,11 +225,12 @@ static struct usb_endpoint_descriptor fs_out_desc __initdata = {
 };
 
 static struct usb_descriptor_header *eth_fs_function[] __initdata = {
+        (struct usb_descriptor_header *) &rndis_iad_descriptor,
         /* control interface matches ACM, not Ethernet */
         (struct usb_descriptor_header *) &rndis_control_intf,
         (struct usb_descriptor_header *) &header_desc,
         (struct usb_descriptor_header *) &call_mgmt_descriptor,
-        (struct usb_descriptor_header *) &acm_descriptor,
+        (struct usb_descriptor_header *) &rndis_acm_descriptor,
         (struct usb_descriptor_header *) &rndis_union_desc,
         (struct usb_descriptor_header *) &fs_notify_desc,
         /* data interface has no altsetting */
@@ -252,11 +270,12 @@ static struct usb_endpoint_descriptor hs_out_desc __initdata = {
 };
 
 static struct usb_descriptor_header *eth_hs_function[] __initdata = {
+        (struct usb_descriptor_header *) &rndis_iad_descriptor,
         /* control interface matches ACM, not Ethernet */
         (struct usb_descriptor_header *) &rndis_control_intf,
         (struct usb_descriptor_header *) &header_desc,
         (struct usb_descriptor_header *) &call_mgmt_descriptor,
-        (struct usb_descriptor_header *) &acm_descriptor,
+        (struct usb_descriptor_header *) &rndis_acm_descriptor,
         (struct usb_descriptor_header *) &rndis_union_desc,
         (struct usb_descriptor_header *) &hs_notify_desc,
         /* data interface has no altsetting */
@@ -271,6 +290,7 @@ static struct usb_descriptor_header *eth_hs_function[] __initdata = {
 static struct usb_string rndis_string_defs[] = {
         [0].s = "RNDIS Communications Control",
         [1].s = "RNDIS Ethernet Data",
+        [2].s = "RNDIS",
         {  } /* end of list */
 };
 
@@ -587,6 +607,7 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
         if (status < 0)
                 goto fail;
         rndis->ctrl_id = status;
+        rndis_iad_descriptor.bFirstInterface = status;
 
         rndis_control_intf.bInterfaceNumber = status;
         rndis_union_desc.bMasterInterface0 = status;
@@ -749,10 +770,6 @@ rndis_unbind(struct usb_configuration *c, struct usb_function *f)
 /* Some controllers can't support RNDIS ... */
 static inline bool can_support_rndis(struct usb_configuration *c)
 {
-        /* only two endpoints on sa1100 */
-        if (gadget_is_sa1100(c->cdev->gadget))
-                return false;
-
         /* everything else is *presumably* fine */
         return true;
 }
@@ -798,6 +815,13 @@ int __init rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
                         return status;
                 rndis_string_defs[1].id = status;
                 rndis_data_intf.iInterface = status;
+
+                /* IAD iFunction label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                rndis_string_defs[2].id = status;
+                rndis_iad_descriptor.iFunction = status;
         }
 
         /* allocate and initialize one new instance */
diff --git a/drivers/usb/gadget/f_serial.c b/drivers/usb/gadget/f_serial.c
index db0aa93606ef..490b00b01a7d 100644
--- a/drivers/usb/gadget/f_serial.c
+++ b/drivers/usb/gadget/f_serial.c
@@ -10,6 +10,7 @@
  * either version 2 of that License or (at your option) any later version.
  */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 
diff --git a/drivers/usb/gadget/f_sourcesink.c b/drivers/usb/gadget/f_sourcesink.c
index 09cba273d2db..6d3cc443d914 100644
--- a/drivers/usb/gadget/f_sourcesink.c
+++ b/drivers/usb/gadget/f_sourcesink.c
@@ -21,6 +21,7 @@
 
 /* #define VERBOSE_DEBUG */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 
diff --git a/drivers/usb/gadget/f_subset.c b/drivers/usb/gadget/f_subset.c
index a9c98fdb626d..8675ca415329 100644
--- a/drivers/usb/gadget/f_subset.c
+++ b/drivers/usb/gadget/f_subset.c
@@ -19,6 +19,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <linux/etherdevice.h>
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 1e6aa504d58a..b49d86e3e45b 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -248,8 +248,6 @@
 #include <linux/freezer.h>
 #include <linux/utsname.h>
 
-#include <asm/unaligned.h>
-
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 
@@ -274,21 +272,20 @@
 #define DRIVER_NAME             "g_file_storage"
 #define DRIVER_VERSION          "20 November 2008"
 
-static const char longname[] = DRIVER_DESC;
-static const char shortname[] = DRIVER_NAME;
+static       char fsg_string_manufacturer[64];
+static const char fsg_string_product[] = DRIVER_DESC;
+static       char fsg_string_serial[13];
+static const char fsg_string_config[] = "Self-powered";
+static const char fsg_string_interface[] = "Mass Storage";
+
+
+#include "storage_common.c"
+
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR("Alan Stern");
 MODULE_LICENSE("Dual BSD/GPL");
 
-/* Thanks to NetChip Technologies for donating this product ID.
- *
- * DO NOT REUSE THESE IDs with any other driver!!  Ever!!
- * Instead:  allocate your own, using normal USB-IF procedures. */
-#define DRIVER_VENDOR_ID        0x0525  // NetChip
-#define DRIVER_PRODUCT_ID       0xa4a5  // Linux-USB File-backed Storage Gadget
-
-
 /*
  * This driver assumes self-powered hardware and has no way for users to
  * trigger remote wakeup.  It uses autoconfiguration to select endpoints
@@ -298,54 +295,12 @@ MODULE_LICENSE("Dual BSD/GPL");
 
 /*-------------------------------------------------------------------------*/
 
-#define LDBG(lun,fmt,args...) \
-        dev_dbg(&(lun)->dev , fmt , ## args)
-#define MDBG(fmt,args...) \
-        pr_debug(DRIVER_NAME ": " fmt , ## args)
-
-#ifndef DEBUG
-#undef VERBOSE_DEBUG
-#undef DUMP_MSGS
-#endif /* !DEBUG */
-
-#ifdef VERBOSE_DEBUG
-#define VLDBG   LDBG
-#else
-#define VLDBG(lun,fmt,args...) \
-        do { } while (0)
-#endif /* VERBOSE_DEBUG */
-
-#define LERROR(lun,fmt,args...) \
-        dev_err(&(lun)->dev , fmt , ## args)
-#define LWARN(lun,fmt,args...) \
-        dev_warn(&(lun)->dev , fmt , ## args)
-#define LINFO(lun,fmt,args...) \
-        dev_info(&(lun)->dev , fmt , ## args)
-
-#define MINFO(fmt,args...) \
-        pr_info(DRIVER_NAME ": " fmt , ## args)
-
-#define DBG(d, fmt, args...) \
-        dev_dbg(&(d)->gadget->dev , fmt , ## args)
-#define VDBG(d, fmt, args...) \
-        dev_vdbg(&(d)->gadget->dev , fmt , ## args)
-#define ERROR(d, fmt, args...) \
-        dev_err(&(d)->gadget->dev , fmt , ## args)
-#define WARNING(d, fmt, args...) \
-        dev_warn(&(d)->gadget->dev , fmt , ## args)
-#define INFO(d, fmt, args...) \
-        dev_info(&(d)->gadget->dev , fmt , ## args)
-
-
-/*-------------------------------------------------------------------------*/
 
 /* Encapsulate the module parameter settings */
 
-#define MAX_LUNS        8
-
 static struct {
-        char            *file[MAX_LUNS];
-        int             ro[MAX_LUNS];
+        char            *file[FSG_MAX_LUNS];
+        int             ro[FSG_MAX_LUNS];
         unsigned int    num_filenames;
         unsigned int    num_ros;
         unsigned int    nluns;
@@ -372,8 +327,8 @@ static struct {
         .removable              = 0,
         .can_stall              = 1,
         .cdrom                  = 0,
-        .vendor                 = DRIVER_VENDOR_ID,
-        .product                = DRIVER_PRODUCT_ID,
+        .vendor                 = FSG_VENDOR_ID,
+        .product                = FSG_PRODUCT_ID,
         .release                = 0xffff,       // Use controller chip type
         .buflen                 = 16384,
         };
@@ -425,125 +380,6 @@ MODULE_PARM_DESC(buflen, "I/O buffer size");
 #endif /* CONFIG_USB_FILE_STORAGE_TEST */
 
 
-/*-------------------------------------------------------------------------*/
-
-/* SCSI device types */
-#define TYPE_DISK       0x00
-#define TYPE_CDROM      0x05
-
-/* USB protocol value = the transport method */
-#define USB_PR_CBI      0x00            // Control/Bulk/Interrupt
-#define USB_PR_CB       0x01            // Control/Bulk w/o interrupt
-#define USB_PR_BULK     0x50            // Bulk-only
-
-/* USB subclass value = the protocol encapsulation */
-#define USB_SC_RBC      0x01            // Reduced Block Commands (flash)
-#define USB_SC_8020     0x02            // SFF-8020i, MMC-2, ATAPI (CD-ROM)
-#define USB_SC_QIC      0x03            // QIC-157 (tape)
-#define USB_SC_UFI      0x04            // UFI (floppy)
-#define USB_SC_8070     0x05            // SFF-8070i (removable)
-#define USB_SC_SCSI     0x06            // Transparent SCSI
-
-/* Bulk-only data structures */
-
-/* Command Block Wrapper */
-struct bulk_cb_wrap {
-        __le32  Signature;              // Contains 'USBC'
-        u32     Tag;                    // Unique per command id
-        __le32  DataTransferLength;     // Size of the data
-        u8      Flags;                  // Direction in bit 7
-        u8      Lun;                    // LUN (normally 0)
-        u8      Length;                 // Of the CDB, <= MAX_COMMAND_SIZE
-        u8      CDB[16];                // Command Data Block
-};
-
-#define USB_BULK_CB_WRAP_LEN    31
-#define USB_BULK_CB_SIG         0x43425355      // Spells out USBC
-#define USB_BULK_IN_FLAG        0x80
-
-/* Command Status Wrapper */
-struct bulk_cs_wrap {
-        __le32  Signature;              // Should = 'USBS'
-        u32     Tag;                    // Same as original command
-        __le32  Residue;                // Amount not transferred
-        u8      Status;                 // See below
-};
-
-#define USB_BULK_CS_WRAP_LEN    13
-#define USB_BULK_CS_SIG         0x53425355      // Spells out 'USBS'
-#define USB_STATUS_PASS         0
-#define USB_STATUS_FAIL         1
-#define USB_STATUS_PHASE_ERROR  2
-
-/* Bulk-only class specific requests */
-#define USB_BULK_RESET_REQUEST          0xff
-#define USB_BULK_GET_MAX_LUN_REQUEST    0xfe
-
-
-/* CBI Interrupt data structure */
-struct interrupt_data {
-        u8      bType;
-        u8      bValue;
-};
-
-#define CBI_INTERRUPT_DATA_LEN          2
-
-/* CBI Accept Device-Specific Command request */
-#define USB_CBI_ADSC_REQUEST            0x00
-
-
-#define MAX_COMMAND_SIZE        16      // Length of a SCSI Command Data Block
-
-/* SCSI commands that we recognize */
-#define SC_FORMAT_UNIT                  0x04
-#define SC_INQUIRY                      0x12
-#define SC_MODE_SELECT_6                0x15
-#define SC_MODE_SELECT_10               0x55
-#define SC_MODE_SENSE_6                 0x1a
-#define SC_MODE_SENSE_10                0x5a
-#define SC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
-#define SC_READ_6                       0x08
-#define SC_READ_10                      0x28
-#define SC_READ_12                      0xa8
-#define SC_READ_CAPACITY                0x25
-#define SC_READ_FORMAT_CAPACITIES       0x23
-#define SC_READ_HEADER                  0x44
-#define SC_READ_TOC                     0x43
-#define SC_RELEASE                      0x17
-#define SC_REQUEST_SENSE                0x03
-#define SC_RESERVE                      0x16
-#define SC_SEND_DIAGNOSTIC              0x1d
-#define SC_START_STOP_UNIT              0x1b
-#define SC_SYNCHRONIZE_CACHE            0x35
-#define SC_TEST_UNIT_READY              0x00
-#define SC_VERIFY                       0x2f
-#define SC_WRITE_6                      0x0a
-#define SC_WRITE_10                     0x2a
-#define SC_WRITE_12                     0xaa
-
-/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
-#define SS_NO_SENSE                             0
-#define SS_COMMUNICATION_FAILURE                0x040800
-#define SS_INVALID_COMMAND                      0x052000
-#define SS_INVALID_FIELD_IN_CDB                 0x052400
-#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE   0x052100
-#define SS_LOGICAL_UNIT_NOT_SUPPORTED           0x052500
-#define SS_MEDIUM_NOT_PRESENT                   0x023a00
-#define SS_MEDIUM_REMOVAL_PREVENTED             0x055302
-#define SS_NOT_READY_TO_READY_TRANSITION        0x062800
-#define SS_RESET_OCCURRED                       0x062900
-#define SS_SAVING_PARAMETERS_NOT_SUPPORTED      0x053900
-#define SS_UNRECOVERED_READ_ERROR               0x031100
-#define SS_WRITE_ERROR                          0x030c02
-#define SS_WRITE_PROTECTED                      0x072700
-
-#define SK(x)           ((u8) ((x) >> 16))      // Sense Key byte, etc.
-#define ASC(x)          ((u8) ((x) >> 8))
-#define ASCQ(x)         ((u8) (x))
-
-
-/*-------------------------------------------------------------------------*/
-
 /*
  * These definitions will permit the compiler to avoid generating code for
  * parts of the driver that aren't used in the non-TEST version.  Even gcc
@@ -566,81 +402,8 @@ struct interrupt_data {
 #endif /* CONFIG_USB_FILE_STORAGE_TEST */
 
 
-struct lun {
-        struct file     *filp;
-        loff_t          file_length;
-        loff_t          num_sectors;
-
-        unsigned int    ro : 1;
-        unsigned int    prevent_medium_removal : 1;
-        unsigned int    registered : 1;
-        unsigned int    info_valid : 1;
-
-        u32             sense_data;
-        u32             sense_data_info;
-        u32             unit_attention_data;
-
-        struct device   dev;
-};
-
-#define backing_file_is_open(curlun)    ((curlun)->filp != NULL)
-
-static struct lun *dev_to_lun(struct device *dev)
-{
-        return container_of(dev, struct lun, dev);
-}
-
-
-/* Big enough to hold our biggest descriptor */
-#define EP0_BUFSIZE     256
-#define DELAYED_STATUS  (EP0_BUFSIZE + 999)     // An impossibly large value
-
-/* Number of buffers we will use.  2 is enough for double-buffering */
-#define NUM_BUFFERS     2
-
-enum fsg_buffer_state {
-        BUF_STATE_EMPTY = 0,
-        BUF_STATE_FULL,
-        BUF_STATE_BUSY
-};
-
-struct fsg_buffhd {
-        void                            *buf;
-        enum fsg_buffer_state           state;
-        struct fsg_buffhd               *next;
-
-        /* The NetChip 2280 is faster, and handles some protocol faults
-         * better, if we don't submit any short bulk-out read requests.
-         * So we will record the intended request length here. */
-        unsigned int                    bulk_out_intended_length;
-
-        struct usb_request              *inreq;
-        int                             inreq_busy;
-        struct usb_request              *outreq;
-        int                             outreq_busy;
-};
-
-enum fsg_state {
-        FSG_STATE_COMMAND_PHASE = -10,          // This one isn't used anywhere
-        FSG_STATE_DATA_PHASE,
-        FSG_STATE_STATUS_PHASE,
-
-        FSG_STATE_IDLE = 0,
-        FSG_STATE_ABORT_BULK_OUT,
-        FSG_STATE_RESET,
-        FSG_STATE_INTERFACE_CHANGE,
-        FSG_STATE_CONFIG_CHANGE,
-        FSG_STATE_DISCONNECT,
-        FSG_STATE_EXIT,
-        FSG_STATE_TERMINATED
-};
+/*-------------------------------------------------------------------------*/
 
-enum data_direction {
-        DATA_DIR_UNKNOWN = 0,
-        DATA_DIR_FROM_HOST,
-        DATA_DIR_TO_HOST,
-        DATA_DIR_NONE
-};
 
 struct fsg_dev {
         /* lock protects: state, all the req_busy's, and cbbuf_cmnd */
@@ -662,7 +425,7 @@ struct fsg_dev {
         int                     intreq_busy;
         struct fsg_buffhd       *intr_buffhd;
 
-        unsigned int            bulk_out_maxpacket;
+        unsigned int            bulk_out_maxpacket;
         enum fsg_state          state;          // For exception handling
         unsigned int            exception_req_tag;
 
@@ -687,7 +450,7 @@ struct fsg_dev {
 
         struct fsg_buffhd       *next_buffhd_to_fill;
         struct fsg_buffhd       *next_buffhd_to_drain;
-        struct fsg_buffhd       buffhds[NUM_BUFFERS];
+        struct fsg_buffhd       buffhds[FSG_NUM_BUFFERS];
 
         int                     thread_wakeup_needed;
         struct completion       thread_notifier;
@@ -712,8 +475,8 @@ struct fsg_dev {
         u8                      cbbuf_cmnd[MAX_COMMAND_SIZE];
 
         unsigned int            nluns;
-        struct lun              *luns;
-        struct lun              *curlun;
+        struct fsg_lun          *luns;
+        struct fsg_lun          *curlun;
 };
 
 typedef void (*fsg_routine_t)(struct fsg_dev *);
@@ -739,49 +502,9 @@ static void set_bulk_out_req_length(struct fsg_dev *fsg,
 static struct fsg_dev                   *the_fsg;
 static struct usb_gadget_driver         fsg_driver;
 
-static void     close_backing_file(struct lun *curlun);
-
 
 /*-------------------------------------------------------------------------*/
 
-#ifdef DUMP_MSGS
-
-static void dump_msg(struct fsg_dev *fsg, const char *label,
-                const u8 *buf, unsigned int length)
-{
-        if (length < 512) {
-                DBG(fsg, "%s, length %u:\n", label, length);
-                print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,
-                                16, 1, buf, length, 0);
-        }
-}
-
-static void dump_cdb(struct fsg_dev *fsg)
-{}
-
-#else
-
-static void dump_msg(struct fsg_dev *fsg, const char *label,
-                const u8 *buf, unsigned int length)
-{}
-
-#ifdef VERBOSE_DEBUG
-
-static void dump_cdb(struct fsg_dev *fsg)
-{
-        print_hex_dump(KERN_DEBUG, "SCSI CDB: ", DUMP_PREFIX_NONE,
-                        16, 1, fsg->cmnd, fsg->cmnd_size, 0);
-}
-
-#else
-
-static void dump_cdb(struct fsg_dev *fsg)
-{}
-
-#endif /* VERBOSE_DEBUG */
-#endif /* DUMP_MSGS */
-
-
 static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
 {
         const char      *name;
@@ -799,26 +522,11 @@ static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
 
 /*-------------------------------------------------------------------------*/
 
-/* Routines for unaligned data access */
-
-static u32 get_unaligned_be24(u8 *buf)
-{
-        return 0xffffff & (u32) get_unaligned_be32(buf - 1);
-}
-
-
-/*-------------------------------------------------------------------------*/
-
 /*
  * DESCRIPTORS ... most are static, but strings and (full) configuration
  * descriptors are built on demand.  Also the (static) config and interface
  * descriptors are adjusted during fsg_bind().
  */
-#define STRING_MANUFACTURER     1
-#define STRING_PRODUCT          2
-#define STRING_SERIAL           3
-#define STRING_CONFIG           4
-#define STRING_INTERFACE        5
 
 /* There is only one configuration. */
 #define CONFIG_VALUE            1
@@ -832,13 +540,13 @@ device_desc = {
         .bDeviceClass =         USB_CLASS_PER_INTERFACE,
 
         /* The next three values can be overridden by module parameters */
-        .idVendor =             cpu_to_le16(DRIVER_VENDOR_ID),
-        .idProduct =            cpu_to_le16(DRIVER_PRODUCT_ID),
+        .idVendor =             cpu_to_le16(FSG_VENDOR_ID),
+        .idProduct =            cpu_to_le16(FSG_PRODUCT_ID),
         .bcdDevice =            cpu_to_le16(0xffff),
 
-        .iManufacturer =        STRING_MANUFACTURER,
-        .iProduct =             STRING_PRODUCT,
-        .iSerialNumber =        STRING_SERIAL,
+        .iManufacturer =        FSG_STRING_MANUFACTURER,
+        .iProduct =             FSG_STRING_PRODUCT,
+        .iSerialNumber =        FSG_STRING_SERIAL,
         .bNumConfigurations =   1,
 };
 
@@ -850,86 +558,12 @@ config_desc = {
         /* wTotalLength computed by usb_gadget_config_buf() */
         .bNumInterfaces =       1,
         .bConfigurationValue =  CONFIG_VALUE,
-        .iConfiguration =       STRING_CONFIG,
+        .iConfiguration =       FSG_STRING_CONFIG,
         .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
         .bMaxPower =            CONFIG_USB_GADGET_VBUS_DRAW / 2,
 };
 
-static struct usb_otg_descriptor
-otg_desc = {
-        .bLength =              sizeof(otg_desc),
-        .bDescriptorType =      USB_DT_OTG,
-
-        .bmAttributes =         USB_OTG_SRP,
-};
-
-/* There is only one interface. */
-
-static struct usb_interface_descriptor
-intf_desc = {
-        .bLength =              sizeof intf_desc,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bNumEndpoints =        2,              // Adjusted during fsg_bind()
-        .bInterfaceClass =      USB_CLASS_MASS_STORAGE,
-        .bInterfaceSubClass =   USB_SC_SCSI,    // Adjusted during fsg_bind()
-        .bInterfaceProtocol =   USB_PR_BULK,    // Adjusted during fsg_bind()
-        .iInterface =           STRING_INTERFACE,
-};
-
-/* Three full-speed endpoint descriptors: bulk-in, bulk-out,
- * and interrupt-in. */
-
-static struct usb_endpoint_descriptor
-fs_bulk_in_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        /* wMaxPacketSize set by autoconfiguration */
-};
 
-static struct usb_endpoint_descriptor
-fs_bulk_out_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_OUT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        /* wMaxPacketSize set by autoconfiguration */
-};
-
-static struct usb_endpoint_descriptor
-fs_intr_in_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       cpu_to_le16(2),
-        .bInterval =            32,     // frames -> 32 ms
-};
-
-static const struct usb_descriptor_header *fs_function[] = {
-        (struct usb_descriptor_header *) &otg_desc,
-        (struct usb_descriptor_header *) &intf_desc,
-        (struct usb_descriptor_header *) &fs_bulk_in_desc,
-        (struct usb_descriptor_header *) &fs_bulk_out_desc,
-        (struct usb_descriptor_header *) &fs_intr_in_desc,
-        NULL,
-};
-#define FS_FUNCTION_PRE_EP_ENTRIES      2
-
-
-/*
- * USB 2.0 devices need to expose both high speed and full speed
- * descriptors, unless they only run at full speed.
- *
- * That means alternate endpoint descriptors (bigger packets)
- * and a "device qualifier" ... plus more construction options
- * for the config descriptor.
- */
 static struct usb_qualifier_descriptor
 dev_qualifier = {
         .bLength =              sizeof dev_qualifier,
@@ -941,78 +575,6 @@ dev_qualifier = {
         .bNumConfigurations =   1,
 };
 
-static struct usb_endpoint_descriptor
-hs_bulk_in_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       cpu_to_le16(512),
-};
-
-static struct usb_endpoint_descriptor
-hs_bulk_out_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       cpu_to_le16(512),
-        .bInterval =            1,      // NAK every 1 uframe
-};
-
-static struct usb_endpoint_descriptor
-hs_intr_in_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        /* bEndpointAddress copied from fs_intr_in_desc during fsg_bind() */
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       cpu_to_le16(2),
-        .bInterval =            9,      // 2**(9-1) = 256 uframes -> 32 ms
-};
-
-static const struct usb_descriptor_header *hs_function[] = {
-        (struct usb_descriptor_header *) &otg_desc,
-        (struct usb_descriptor_header *) &intf_desc,
-        (struct usb_descriptor_header *) &hs_bulk_in_desc,
-        (struct usb_descriptor_header *) &hs_bulk_out_desc,
-        (struct usb_descriptor_header *) &hs_intr_in_desc,
-        NULL,
-};
-#define HS_FUNCTION_PRE_EP_ENTRIES      2
-
-/* Maxpacket and other transfer characteristics vary by speed. */
-static struct usb_endpoint_descriptor *
-ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *fs,
-                struct usb_endpoint_descriptor *hs)
-{
-        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
-                return hs;
-        return fs;
-}
-
-
-/* The CBI specification limits the serial string to 12 uppercase hexadecimal
- * characters. */
-static char                             manufacturer[64];
-static char                             serial[13];
-
-/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
-static struct usb_string                strings[] = {
-        {STRING_MANUFACTURER,   manufacturer},
-        {STRING_PRODUCT,        longname},
-        {STRING_SERIAL,         serial},
-        {STRING_CONFIG,         "Self-powered"},
-        {STRING_INTERFACE,      "Mass Storage"},
-        {}
-};
-
-static struct usb_gadget_strings        stringtab = {
-        .language       = 0x0409,               // en-us
-        .strings        = strings,
-};
 
 
 /*
@@ -1032,10 +594,9 @@ static int populate_config_buf(struct usb_gadget *gadget,
 
         if (gadget_is_dualspeed(gadget) && type == USB_DT_OTHER_SPEED_CONFIG)
                 speed = (USB_SPEED_FULL + USB_SPEED_HIGH) - speed;
-        if (gadget_is_dualspeed(gadget) && speed == USB_SPEED_HIGH)
-                function = hs_function;
-        else
-                function = fs_function;
+        function = gadget_is_dualspeed(gadget) && speed == USB_SPEED_HIGH
+                ? (const struct usb_descriptor_header **)fsg_hs_function
+                : (const struct usb_descriptor_header **)fsg_fs_function;
 
         /* for now, don't advertise srp-only devices */
         if (!gadget_is_otg(gadget))
@@ -1386,7 +947,7 @@ get_config:
                         VDBG(fsg, "get string descriptor\n");
 
                         /* wIndex == language code */
-                        value = usb_gadget_get_string(&stringtab,
+                        value = usb_gadget_get_string(&fsg_stringtab,
                                         w_value & 0xff, req->buf);
                         break;
                 }
@@ -1551,7 +1112,7 @@ static int sleep_thread(struct fsg_dev *fsg)
 
 static int do_read(struct fsg_dev *fsg)
 {
-        struct lun              *curlun = fsg->curlun;
+        struct fsg_lun          *curlun = fsg->curlun;
         u32                     lba;
         struct fsg_buffhd       *bh;
         int                     rc;
@@ -1677,7 +1238,7 @@ static int do_read(struct fsg_dev *fsg)
 
 static int do_write(struct fsg_dev *fsg)
 {
-        struct lun              *curlun = fsg->curlun;
+        struct fsg_lun          *curlun = fsg->curlun;
         u32                     lba;
         struct fsg_buffhd       *bh;
         int                     get_some_more;
@@ -1713,7 +1274,7 @@ static int do_write(struct fsg_dev *fsg)
                 }
                 if (fsg->cmnd[1] & 0x08) {      // FUA
                         spin_lock(&curlun->filp->f_lock);
-                        curlun->filp->f_flags |= O_SYNC;
+                        curlun->filp->f_flags |= O_DSYNC;
                         spin_unlock(&curlun->filp->f_lock);
                 }
         }
@@ -1864,33 +1425,14 @@ static int do_write(struct fsg_dev *fsg)
 
 /*-------------------------------------------------------------------------*/
 
-/* Sync the file data, don't bother with the metadata.
- * This code was copied from fs/buffer.c:sys_fdatasync(). */
-static int fsync_sub(struct lun *curlun)
-{
-        struct file     *filp = curlun->filp;
-
-        if (curlun->ro || !filp)
-                return 0;
-        return vfs_fsync(filp, filp->f_path.dentry, 1);
-}
-
-static void fsync_all(struct fsg_dev *fsg)
-{
-        int     i;
-
-        for (i = 0; i < fsg->nluns; ++i)
-                fsync_sub(&fsg->luns[i]);
-}
-
 static int do_synchronize_cache(struct fsg_dev *fsg)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
         int             rc;
 
         /* We ignore the requested LBA and write out all file's
          * dirty data buffers. */
-        rc = fsync_sub(curlun);
+        rc = fsg_lun_fsync_sub(curlun);
         if (rc)
                 curlun->sense_data = SS_WRITE_ERROR;
         return 0;
@@ -1899,19 +1441,19 @@ static int do_synchronize_cache(struct fsg_dev *fsg)
 
 /*-------------------------------------------------------------------------*/
 
-static void invalidate_sub(struct lun *curlun)
+static void invalidate_sub(struct fsg_lun *curlun)
 {
         struct file     *filp = curlun->filp;
         struct inode    *inode = filp->f_path.dentry->d_inode;
         unsigned long   rc;
 
         rc = invalidate_mapping_pages(inode->i_mapping, 0, -1);
-        VLDBG(curlun, "invalidate_inode_pages -> %ld\n", rc);
+        VLDBG(curlun, "invalidate_mapping_pages -> %ld\n", rc);
 }
 
 static int do_verify(struct fsg_dev *fsg)
 {
-        struct lun              *curlun = fsg->curlun;
+        struct fsg_lun          *curlun = fsg->curlun;
         u32                     lba;
         u32                     verification_length;
         struct fsg_buffhd       *bh = fsg->next_buffhd_to_fill;
@@ -1944,7 +1486,7 @@ static int do_verify(struct fsg_dev *fsg)
         file_offset = ((loff_t) lba) << 9;
 
         /* Write out all the dirty buffers before invalidating them */
-        fsync_sub(curlun);
+        fsg_lun_fsync_sub(curlun);
         if (signal_pending(current))
                 return -EINTR;
 
@@ -2041,7 +1583,7 @@ static int do_inquiry(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 
 static int do_request_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
         u8              *buf = (u8 *) bh->buf;
         u32             sd, sdinfo;
         int             valid;
@@ -2095,7 +1637,7 @@ static int do_request_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 
 static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
         u32             lba = get_unaligned_be32(&fsg->cmnd[2]);
         int             pmi = fsg->cmnd[8];
         u8              *buf = (u8 *) bh->buf;
@@ -2113,27 +1655,9 @@ static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 }
 
 
-static void store_cdrom_address(u8 *dest, int msf, u32 addr)
-{
-        if (msf) {
-                /* Convert to Minutes-Seconds-Frames */
-                addr >>= 2;             /* Convert to 2048-byte frames */
-                addr += 2*75;           /* Lead-in occupies 2 seconds */
-                dest[3] = addr % 75;    /* Frames */
-                addr /= 75;
-                dest[2] = addr % 60;    /* Seconds */
-                addr /= 60;
-                dest[1] = addr;         /* Minutes */
-                dest[0] = 0;            /* Reserved */
-        } else {
-                /* Absolute sector */
-                put_unaligned_be32(addr, dest);
-        }
-}
-
 static int do_read_header(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
         int             msf = fsg->cmnd[1] & 0x02;
         u32             lba = get_unaligned_be32(&fsg->cmnd[2]);
         u8              *buf = (u8 *) bh->buf;
@@ -2156,7 +1680,7 @@ static int do_read_header(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 
 static int do_read_toc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
         int             msf = fsg->cmnd[1] & 0x02;
         int             start_track = fsg->cmnd[6];
         u8              *buf = (u8 *) bh->buf;
@@ -2184,7 +1708,7 @@ static int do_read_toc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 
 static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
         int             mscmnd = fsg->cmnd[0];
         u8              *buf = (u8 *) bh->buf;
         u8              *buf0 = buf;
@@ -2265,7 +1789,7 @@ static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 
 static int do_start_stop(struct fsg_dev *fsg)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
         int             loej, start;
 
         if (!mod_data.removable) {
@@ -2295,7 +1819,7 @@ static int do_start_stop(struct fsg_dev *fsg)
                 if (loej) {             // Simulate an unload/eject
                         up_read(&fsg->filesem);
                         down_write(&fsg->filesem);
-                        close_backing_file(curlun);
+                        fsg_lun_close(curlun);
                         up_write(&fsg->filesem);
                         down_read(&fsg->filesem);
                 }
@@ -2303,7 +1827,7 @@ static int do_start_stop(struct fsg_dev *fsg)
 
                 /* Our emulation doesn't support mounting; the medium is
                  * available for use as soon as it is loaded. */
-                if (!backing_file_is_open(curlun)) {
+                if (!fsg_lun_is_open(curlun)) {
                         curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
                         return -EINVAL;
                 }
@@ -2315,7 +1839,7 @@ static int do_start_stop(struct fsg_dev *fsg)
 
 static int do_prevent_allow(struct fsg_dev *fsg)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
         int             prevent;
 
         if (!mod_data.removable) {
@@ -2330,7 +1854,7 @@ static int do_prevent_allow(struct fsg_dev *fsg)
         }
 
         if (curlun->prevent_medium_removal && !prevent)
-                fsync_sub(curlun);
+                fsg_lun_fsync_sub(curlun);
         curlun->prevent_medium_removal = prevent;
         return 0;
 }
@@ -2339,7 +1863,7 @@ static int do_prevent_allow(struct fsg_dev *fsg)
 static int do_read_format_capacities(struct fsg_dev *fsg,
                         struct fsg_buffhd *bh)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
         u8              *buf = (u8 *) bh->buf;
 
         buf[0] = buf[1] = buf[2] = 0;
@@ -2356,7 +1880,7 @@ static int do_read_format_capacities(struct fsg_dev *fsg,
 
 static int do_mode_select(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
-        struct lun      *curlun = fsg->curlun;
+        struct fsg_lun  *curlun = fsg->curlun;
 
         /* We don't support MODE SELECT */
         curlun->sense_data = SS_INVALID_COMMAND;
@@ -2599,7 +2123,7 @@ static int finish_reply(struct fsg_dev *fsg)
 
 static int send_status(struct fsg_dev *fsg)
 {
-        struct lun              *curlun = fsg->curlun;
+        struct fsg_lun          *curlun = fsg->curlun;
         struct fsg_buffhd       *bh;
         int                     rc;
         u8                      status = USB_STATUS_PASS;
@@ -2691,7 +2215,7 @@ static int check_command(struct fsg_dev *fsg, int cmnd_size,
         int                     lun = fsg->cmnd[1] >> 5;
         static const char       dirletter[4] = {'u', 'o', 'i', 'n'};
         char                    hdlen[20];
-        struct lun              *curlun;
+        struct fsg_lun          *curlun;
 
         /* Adjust the expected cmnd_size for protocol encapsulation padding.
          * Transparent SCSI doesn't pad. */
@@ -2820,7 +2344,7 @@ static int check_command(struct fsg_dev *fsg, int cmnd_size,
 
         /* If the medium isn't mounted and the command needs to access
          * it, return an error. */
-        if (curlun && !backing_file_is_open(curlun) && needs_medium) {
+        if (curlun && !fsg_lun_is_open(curlun) && needs_medium) {
                 curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
                 return -EINVAL;
         }
@@ -3075,8 +2599,8 @@ static int do_scsi_command(struct fsg_dev *fsg)
 
 static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
-        struct usb_request      *req = bh->outreq;
-        struct bulk_cb_wrap     *cbw = req->buf;
+        struct usb_request              *req = bh->outreq;
+        struct fsg_bulk_cb_wrap *cbw = req->buf;
 
         /* Was this a real packet?  Should it be ignored? */
         if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
@@ -3105,7 +2629,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         }
 
         /* Is the CBW meaningful? */
-        if (cbw->Lun >= MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
+        if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
                         cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
                 DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
                                 "cmdlen %u\n",
@@ -3238,7 +2762,7 @@ static int do_set_interface(struct fsg_dev *fsg, int altsetting)
 
 reset:
         /* Deallocate the requests */
-        for (i = 0; i < NUM_BUFFERS; ++i) {
+        for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
                 struct fsg_buffhd *bh = &fsg->buffhds[i];
 
                 if (bh->inreq) {
@@ -3276,12 +2800,14 @@ reset:
         DBG(fsg, "set interface %d\n", altsetting);
 
         /* Enable the endpoints */
-        d = ep_desc(fsg->gadget, &fs_bulk_in_desc, &hs_bulk_in_desc);
+        d = fsg_ep_desc(fsg->gadget,
+                        &fsg_fs_bulk_in_desc, &fsg_hs_bulk_in_desc);
         if ((rc = enable_endpoint(fsg, fsg->bulk_in, d)) != 0)
                 goto reset;
         fsg->bulk_in_enabled = 1;
 
-        d = ep_desc(fsg->gadget, &fs_bulk_out_desc, &hs_bulk_out_desc);
+        d = fsg_ep_desc(fsg->gadget,
+                        &fsg_fs_bulk_out_desc, &fsg_hs_bulk_out_desc);
         if ((rc = enable_endpoint(fsg, fsg->bulk_out, d)) != 0)
                 goto reset;
         fsg->bulk_out_enabled = 1;
@@ -3289,14 +2815,15 @@ reset:
         clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
 
         if (transport_is_cbi()) {
-                d = ep_desc(fsg->gadget, &fs_intr_in_desc, &hs_intr_in_desc);
+                d = fsg_ep_desc(fsg->gadget,
+                                &fsg_fs_intr_in_desc, &fsg_hs_intr_in_desc);
                 if ((rc = enable_endpoint(fsg, fsg->intr_in, d)) != 0)
                         goto reset;
                 fsg->intr_in_enabled = 1;
         }
 
         /* Allocate the requests */
-        for (i = 0; i < NUM_BUFFERS; ++i) {
+        for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
                 struct fsg_buffhd       *bh = &fsg->buffhds[i];
 
                 if ((rc = alloc_request(fsg, fsg->bulk_in, &bh->inreq)) != 0)
@@ -3372,7 +2899,7 @@ static void handle_exception(struct fsg_dev *fsg)
         struct fsg_buffhd       *bh;
         enum fsg_state          old_state;
         u8                      new_config;
-        struct lun              *curlun;
+        struct fsg_lun          *curlun;
         unsigned int            exception_req_tag;
         int                     rc;
 
@@ -3392,7 +2919,7 @@ static void handle_exception(struct fsg_dev *fsg)
         /* Cancel all the pending transfers */
         if (fsg->intreq_busy)
                 usb_ep_dequeue(fsg->intr_in, fsg->intreq);
-        for (i = 0; i < NUM_BUFFERS; ++i) {
+        for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
                 bh = &fsg->buffhds[i];
                 if (bh->inreq_busy)
                         usb_ep_dequeue(fsg->bulk_in, bh->inreq);
@@ -3403,7 +2930,7 @@ static void handle_exception(struct fsg_dev *fsg)
         /* Wait until everything is idle */
         for (;;) {
                 num_active = fsg->intreq_busy;
-                for (i = 0; i < NUM_BUFFERS; ++i) {
+                for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
                         bh = &fsg->buffhds[i];
                         num_active += bh->inreq_busy + bh->outreq_busy;
                 }
@@ -3425,7 +2952,7 @@ static void handle_exception(struct fsg_dev *fsg)
          * state, and the exception.  Then invoke the handler. */
         spin_lock_irq(&fsg->lock);
 
-        for (i = 0; i < NUM_BUFFERS; ++i) {
+        for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
                 bh = &fsg->buffhds[i];
                 bh->state = BUF_STATE_EMPTY;
         }
@@ -3506,7 +3033,8 @@ static void handle_exception(struct fsg_dev *fsg)
                 break;
 
         case FSG_STATE_DISCONNECT:
-                fsync_all(fsg);
+                for (i = 0; i < fsg->nluns; ++i)
+                        fsg_lun_fsync_sub(fsg->luns + i);
                 do_set_config(fsg, 0);          // Unconfigured state
                 break;
 
@@ -3595,201 +3123,10 @@ static int fsg_main_thread(void *fsg_)
 
 /*-------------------------------------------------------------------------*/
 
-/* If the next two routines are called while the gadget is registered,
- * the caller must own fsg->filesem for writing. */
-
-static int open_backing_file(struct lun *curlun, const char *filename)
-{
-        int                             ro;
-        struct file                     *filp = NULL;
-        int                             rc = -EINVAL;
-        struct inode                    *inode = NULL;
-        loff_t                          size;
-        loff_t                          num_sectors;
-        loff_t                          min_sectors;
-
-        /* R/W if we can, R/O if we must */
-        ro = curlun->ro;
-        if (!ro) {
-                filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
-                if (-EROFS == PTR_ERR(filp))
-                        ro = 1;
-        }
-        if (ro)
-                filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
-        if (IS_ERR(filp)) {
-                LINFO(curlun, "unable to open backing file: %s\n", filename);
-                return PTR_ERR(filp);
-        }
-
-        if (!(filp->f_mode & FMODE_WRITE))
-                ro = 1;
-
-        if (filp->f_path.dentry)
-                inode = filp->f_path.dentry->d_inode;
-        if (inode && S_ISBLK(inode->i_mode)) {
-                if (bdev_read_only(inode->i_bdev))
-                        ro = 1;
-        } else if (!inode || !S_ISREG(inode->i_mode)) {
-                LINFO(curlun, "invalid file type: %s\n", filename);
-                goto out;
-        }
-
-        /* If we can't read the file, it's no good.
-         * If we can't write the file, use it read-only. */
-        if (!filp->f_op || !(filp->f_op->read || filp->f_op->aio_read)) {
-                LINFO(curlun, "file not readable: %s\n", filename);
-                goto out;
-        }
-        if (!(filp->f_op->write || filp->f_op->aio_write))
-                ro = 1;
-
-        size = i_size_read(inode->i_mapping->host);
-        if (size < 0) {
-                LINFO(curlun, "unable to find file size: %s\n", filename);
-                rc = (int) size;
-                goto out;
-        }
-        num_sectors = size >> 9;        // File size in 512-byte blocks
-        min_sectors = 1;
-        if (mod_data.cdrom) {
-                num_sectors &= ~3;      // Reduce to a multiple of 2048
-                min_sectors = 300*4;    // Smallest track is 300 frames
-                if (num_sectors >= 256*60*75*4) {
-                        num_sectors = (256*60*75 - 1) * 4;
-                        LINFO(curlun, "file too big: %s\n", filename);
-                        LINFO(curlun, "using only first %d blocks\n",
-                                        (int) num_sectors);
-                }
-        }
-        if (num_sectors < min_sectors) {
-                LINFO(curlun, "file too small: %s\n", filename);
-                rc = -ETOOSMALL;
-                goto out;
-        }
-
-        get_file(filp);
-        curlun->ro = ro;
-        curlun->filp = filp;
-        curlun->file_length = size;
-        curlun->num_sectors = num_sectors;
-        LDBG(curlun, "open backing file: %s\n", filename);
-        rc = 0;
-
-out:
-        filp_close(filp, current->files);
-        return rc;
-}
-
-
-static void close_backing_file(struct lun *curlun)
-{
-        if (curlun->filp) {
-                LDBG(curlun, "close backing file\n");
-                fput(curlun->filp);
-                curlun->filp = NULL;
-        }
-}
-
-
-static ssize_t show_ro(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct lun      *curlun = dev_to_lun(dev);
-
-        return sprintf(buf, "%d\n", curlun->ro);
-}
-
-static ssize_t show_file(struct device *dev, struct device_attribute *attr,
-                char *buf)
-{
-        struct lun      *curlun = dev_to_lun(dev);
-        struct fsg_dev  *fsg = dev_get_drvdata(dev);
-        char            *p;
-        ssize_t         rc;
-
-        down_read(&fsg->filesem);
-        if (backing_file_is_open(curlun)) {     // Get the complete pathname
-                p = d_path(&curlun->filp->f_path, buf, PAGE_SIZE - 1);
-                if (IS_ERR(p))
-                        rc = PTR_ERR(p);
-                else {
-                        rc = strlen(p);
-                        memmove(buf, p, rc);
-                        buf[rc] = '\n';         // Add a newline
-                        buf[++rc] = 0;
-                }
-        } else {                                // No file, return 0 bytes
-                *buf = 0;
-                rc = 0;
-        }
-        up_read(&fsg->filesem);
-        return rc;
-}
-
-
-static ssize_t store_ro(struct device *dev, struct device_attribute *attr,
-                const char *buf, size_t count)
-{
-        ssize_t         rc = count;
-        struct lun      *curlun = dev_to_lun(dev);
-        struct fsg_dev  *fsg = dev_get_drvdata(dev);
-        int             i;
-
-        if (sscanf(buf, "%d", &i) != 1)
-                return -EINVAL;
-
-        /* Allow the write-enable status to change only while the backing file
-         * is closed. */
-        down_read(&fsg->filesem);
-        if (backing_file_is_open(curlun)) {
-                LDBG(curlun, "read-only status change prevented\n");
-                rc = -EBUSY;
-        } else {
-                curlun->ro = !!i;
-                LDBG(curlun, "read-only status set to %d\n", curlun->ro);
-        }
-        up_read(&fsg->filesem);
-        return rc;
-}
-
-static ssize_t store_file(struct device *dev, struct device_attribute *attr,
-                const char *buf, size_t count)
-{
-        struct lun      *curlun = dev_to_lun(dev);
-        struct fsg_dev  *fsg = dev_get_drvdata(dev);
-        int             rc = 0;
-
-        if (curlun->prevent_medium_removal && backing_file_is_open(curlun)) {
-                LDBG(curlun, "eject attempt prevented\n");
-                return -EBUSY;                          // "Door is locked"
-        }
-
-        /* Remove a trailing newline */
-        if (count > 0 && buf[count-1] == '\n')
-                ((char *) buf)[count-1] = 0;            // Ugh!
-
-        /* Eject current medium */
-        down_write(&fsg->filesem);
-        if (backing_file_is_open(curlun)) {
-                close_backing_file(curlun);
-                curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
-        }
-
-        /* Load new medium */
-        if (count > 0 && buf[0]) {
-                rc = open_backing_file(curlun, buf);
-                if (rc == 0)
-                        curlun->unit_attention_data =
-                                        SS_NOT_READY_TO_READY_TRANSITION;
-        }
-        up_write(&fsg->filesem);
-        return (rc < 0 ? rc : count);
-}
-
 
 /* The write permissions and store_xxx pointers are set in fsg_bind() */
-static DEVICE_ATTR(ro, 0444, show_ro, NULL);
-static DEVICE_ATTR(file, 0444, show_file, NULL);
+static DEVICE_ATTR(ro, 0444, fsg_show_ro, NULL);
+static DEVICE_ATTR(file, 0444, fsg_show_file, NULL);
 
 
 /*-------------------------------------------------------------------------*/
@@ -3804,7 +3141,9 @@ static void fsg_release(struct kref *ref)
 
 static void lun_release(struct device *dev)
 {
-        struct fsg_dev  *fsg = dev_get_drvdata(dev);
+        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
+        struct fsg_dev          *fsg =
+                container_of(filesem, struct fsg_dev, filesem);
 
         kref_put(&fsg->ref, fsg_release);
 }
@@ -3813,7 +3152,7 @@ static void /* __init_or_exit */ fsg_unbind(struct usb_gadget *gadget)
 {
         struct fsg_dev          *fsg = get_gadget_data(gadget);
         int                     i;
-        struct lun              *curlun;
+        struct fsg_lun          *curlun;
         struct usb_request      *req = fsg->ep0req;
 
         DBG(fsg, "unbind\n");
@@ -3825,7 +3164,7 @@ static void /* __init_or_exit */ fsg_unbind(struct usb_gadget *gadget)
                 if (curlun->registered) {
                         device_remove_file(&curlun->dev, &dev_attr_ro);
                         device_remove_file(&curlun->dev, &dev_attr_file);
-                        close_backing_file(curlun);
+                        fsg_lun_close(curlun);
                         device_unregister(&curlun->dev);
                         curlun->registered = 0;
                 }
@@ -3841,7 +3180,7 @@ static void /* __init_or_exit */ fsg_unbind(struct usb_gadget *gadget)
         }
 
         /* Free the data buffers */
-        for (i = 0; i < NUM_BUFFERS; ++i)
+        for (i = 0; i < FSG_NUM_BUFFERS; ++i)
                 kfree(fsg->buffhds[i].buf);
 
         /* Free the request and buffer for endpoint 0 */
@@ -3869,15 +3208,11 @@ static int __init check_parameters(struct fsg_dev *fsg)
          * halt bulk endpoints correctly.  If one of them is present,
          * disable stalls.
          */
-        if (gadget_is_sh(fsg->gadget) || gadget_is_at91(fsg->gadget))
+        if (gadget_is_at91(fsg->gadget))
                 mod_data.can_stall = 0;
 
         if (mod_data.release == 0xffff) {       // Parameter wasn't set
-                /* The sa1100 controller is not supported */
-                if (gadget_is_sa1100(fsg->gadget))
-                        gcnum = -1;
-                else
-                        gcnum = usb_gadget_controller_number(fsg->gadget);
+                gcnum = usb_gadget_controller_number(fsg->gadget);
                 if (gcnum >= 0)
                         mod_data.release = 0x0300 + gcnum;
                 else {
@@ -3948,7 +3283,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         struct fsg_dev          *fsg = the_fsg;
         int                     rc;
         int                     i;
-        struct lun              *curlun;
+        struct fsg_lun          *curlun;
         struct usb_ep           *ep;
         struct usb_request      *req;
         char                    *pathbuf, *p;
@@ -3963,10 +3298,10 @@ static int __init fsg_bind(struct usb_gadget *gadget)
 
         if (mod_data.removable) {       // Enable the store_xxx attributes
                 dev_attr_file.attr.mode = 0644;
-                dev_attr_file.store = store_file;
+                dev_attr_file.store = fsg_store_file;
                 if (!mod_data.cdrom) {
                         dev_attr_ro.attr.mode = 0644;
-                        dev_attr_ro.store = store_ro;
+                        dev_attr_ro.store = fsg_store_ro;
                 }
         }
 
@@ -3974,7 +3309,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         i = mod_data.nluns;
         if (i == 0)
                 i = max(mod_data.num_filenames, 1u);
-        if (i > MAX_LUNS) {
+        if (i > FSG_MAX_LUNS) {
                 ERROR(fsg, "invalid number of LUNs: %d\n", i);
                 rc = -EINVAL;
                 goto out;
@@ -3982,7 +3317,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
 
         /* Create the LUNs, open their backing files, and register the
          * LUN devices in sysfs. */
-        fsg->luns = kzalloc(i * sizeof(struct lun), GFP_KERNEL);
+        fsg->luns = kzalloc(i * sizeof(struct fsg_lun), GFP_KERNEL);
         if (!fsg->luns) {
                 rc = -ENOMEM;
                 goto out;
@@ -3991,13 +3326,14 @@ static int __init fsg_bind(struct usb_gadget *gadget)
 
         for (i = 0; i < fsg->nluns; ++i) {
                 curlun = &fsg->luns[i];
-                curlun->ro = mod_data.ro[i];
-                if (mod_data.cdrom)
-                        curlun->ro = 1;
+                curlun->cdrom = !!mod_data.cdrom;
+                curlun->ro = mod_data.cdrom || mod_data.ro[i];
+                curlun->initially_ro = curlun->ro;
+                curlun->removable = mod_data.removable;
                 curlun->dev.release = lun_release;
                 curlun->dev.parent = &gadget->dev;
                 curlun->dev.driver = &fsg_driver.driver;
-                dev_set_drvdata(&curlun->dev, fsg);
+                dev_set_drvdata(&curlun->dev, &fsg->filesem);
                 dev_set_name(&curlun->dev,"%s-lun%d",
                              dev_name(&gadget->dev), i);
 
@@ -4016,7 +3352,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
                 kref_get(&fsg->ref);
 
                 if (mod_data.file[i] && *mod_data.file[i]) {
-                        if ((rc = open_backing_file(curlun,
+                        if ((rc = fsg_lun_open(curlun,
                                         mod_data.file[i])) != 0)
                                 goto out;
                 } else if (!mod_data.removable) {
@@ -4028,20 +3364,20 @@ static int __init fsg_bind(struct usb_gadget *gadget)
 
         /* Find all the endpoints we will use */
         usb_ep_autoconfig_reset(gadget);
-        ep = usb_ep_autoconfig(gadget, &fs_bulk_in_desc);
+        ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_in_desc);
         if (!ep)
                 goto autoconf_fail;
         ep->driver_data = fsg;          // claim the endpoint
         fsg->bulk_in = ep;
 
-        ep = usb_ep_autoconfig(gadget, &fs_bulk_out_desc);
+        ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_out_desc);
         if (!ep)
                 goto autoconf_fail;
         ep->driver_data = fsg;          // claim the endpoint
         fsg->bulk_out = ep;
 
         if (transport_is_cbi()) {
-                ep = usb_ep_autoconfig(gadget, &fs_intr_in_desc);
+                ep = usb_ep_autoconfig(gadget, &fsg_fs_intr_in_desc);
                 if (!ep)
                         goto autoconf_fail;
                 ep->driver_data = fsg;          // claim the endpoint
@@ -4055,28 +3391,28 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         device_desc.bcdDevice = cpu_to_le16(mod_data.release);
 
         i = (transport_is_cbi() ? 3 : 2);       // Number of endpoints
-        intf_desc.bNumEndpoints = i;
-        intf_desc.bInterfaceSubClass = mod_data.protocol_type;
-        intf_desc.bInterfaceProtocol = mod_data.transport_type;
-        fs_function[i + FS_FUNCTION_PRE_EP_ENTRIES] = NULL;
+        fsg_intf_desc.bNumEndpoints = i;
+        fsg_intf_desc.bInterfaceSubClass = mod_data.protocol_type;
+        fsg_intf_desc.bInterfaceProtocol = mod_data.transport_type;
+        fsg_fs_function[i + FSG_FS_FUNCTION_PRE_EP_ENTRIES] = NULL;
 
         if (gadget_is_dualspeed(gadget)) {
-                hs_function[i + HS_FUNCTION_PRE_EP_ENTRIES] = NULL;
+                fsg_hs_function[i + FSG_HS_FUNCTION_PRE_EP_ENTRIES] = NULL;
 
                 /* Assume ep0 uses the same maxpacket value for both speeds */
                 dev_qualifier.bMaxPacketSize0 = fsg->ep0->maxpacket;
 
                 /* Assume endpoint addresses are the same for both speeds */
-                hs_bulk_in_desc.bEndpointAddress =
-                                fs_bulk_in_desc.bEndpointAddress;
-                hs_bulk_out_desc.bEndpointAddress =
-                                fs_bulk_out_desc.bEndpointAddress;
-                hs_intr_in_desc.bEndpointAddress =
-                                fs_intr_in_desc.bEndpointAddress;
+                fsg_hs_bulk_in_desc.bEndpointAddress =
+                        fsg_fs_bulk_in_desc.bEndpointAddress;
+                fsg_hs_bulk_out_desc.bEndpointAddress =
+                        fsg_fs_bulk_out_desc.bEndpointAddress;
+                fsg_hs_intr_in_desc.bEndpointAddress =
+                        fsg_fs_intr_in_desc.bEndpointAddress;
         }
 
         if (gadget_is_otg(gadget))
-                otg_desc.bmAttributes |= USB_OTG_HNP;
+                fsg_otg_desc.bmAttributes |= USB_OTG_HNP;
 
         rc = -ENOMEM;
 
@@ -4090,7 +3426,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         req->complete = ep0_complete;
 
         /* Allocate the data buffers */
-        for (i = 0; i < NUM_BUFFERS; ++i) {
+        for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
                 struct fsg_buffhd       *bh = &fsg->buffhds[i];
 
                 /* Allocate for the bulk-in endpoint.  We assume that
@@ -4101,23 +3437,24 @@ static int __init fsg_bind(struct usb_gadget *gadget)
                         goto out;
                 bh->next = bh + 1;
         }
-        fsg->buffhds[NUM_BUFFERS - 1].next = &fsg->buffhds[0];
+        fsg->buffhds[FSG_NUM_BUFFERS - 1].next = &fsg->buffhds[0];
 
         /* This should reflect the actual gadget power source */
         usb_gadget_set_selfpowered(gadget);
 
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+        snprintf(fsg_string_manufacturer, sizeof fsg_string_manufacturer,
+                        "%s %s with %s",
                         init_utsname()->sysname, init_utsname()->release,
                         gadget->name);
 
         /* On a real device, serial[] would be loaded from permanent
          * storage.  We just encode it from the driver version string. */
-        for (i = 0; i < sizeof(serial) - 2; i += 2) {
+        for (i = 0; i < sizeof fsg_string_serial - 2; i += 2) {
                 unsigned char           c = DRIVER_VERSION[i / 2];
 
                 if (!c)
                         break;
-                sprintf(&serial[i], "%02X", c);
+                sprintf(&fsg_string_serial[i], "%02X", c);
         }
 
         fsg->thread_task = kthread_create(fsg_main_thread, fsg,
@@ -4133,7 +3470,7 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
         for (i = 0; i < fsg->nluns; ++i) {
                 curlun = &fsg->luns[i];
-                if (backing_file_is_open(curlun)) {
+                if (fsg_lun_is_open(curlun)) {
                         p = NULL;
                         if (pathbuf) {
                                 p = d_path(&curlun->filp->f_path,
@@ -4203,7 +3540,7 @@ static struct usb_gadget_driver		fsg_driver = {
 #else
         .speed          = USB_SPEED_FULL,
 #endif
-        .function       = (char *) longname,
+        .function       = (char *) fsg_string_product,
         .bind           = fsg_bind,
         .unbind         = fsg_unbind,
         .disconnect     = fsg_disconnect,
@@ -4212,7 +3549,7 @@ static struct usb_gadget_driver		fsg_driver = {
         .resume         = fsg_resume,
 
         .driver         = {
-                .name           = (char *) shortname,
+                .name           = DRIVER_NAME,
                 .owner          = THIS_MODULE,
                 // .release = ...
                 // .suspend = ...
diff --git a/drivers/usb/gadget/fsl_mx3_udc.c b/drivers/usb/gadget/fsl_mx3_udc.c
index 4bc2bf3d602e..20a802ecaa15 100644
--- a/drivers/usb/gadget/fsl_mx3_udc.c
+++ b/drivers/usb/gadget/fsl_mx3_udc.c
@@ -17,6 +17,8 @@
 #include <linux/fsl_devices.h>
 #include <linux/platform_device.h>
 
+#include <mach/hardware.h>
+
 static struct clk *mxc_ahb_clk;
 static struct clk *mxc_usb_clk;
 
@@ -28,14 +30,16 @@ int fsl_udc_clk_init(struct platform_device *pdev)
 
         pdata = pdev->dev.platform_data;
 
-        mxc_ahb_clk = clk_get(&pdev->dev, "usb_ahb");
-        if (IS_ERR(mxc_ahb_clk))
-                return PTR_ERR(mxc_ahb_clk);
+        if (!cpu_is_mx35()) {
+                mxc_ahb_clk = clk_get(&pdev->dev, "usb_ahb");
+                if (IS_ERR(mxc_ahb_clk))
+                        return PTR_ERR(mxc_ahb_clk);
 
-        ret = clk_enable(mxc_ahb_clk);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "clk_enable(\"usb_ahb\") failed\n");
-                goto eenahb;
+                ret = clk_enable(mxc_ahb_clk);
+                if (ret < 0) {
+                        dev_err(&pdev->dev, "clk_enable(\"usb_ahb\") failed\n");
+                        goto eenahb;
+                }
         }
 
         /* make sure USB_CLK is running at 60 MHz +/- 1000 Hz */
@@ -50,6 +54,7 @@ int fsl_udc_clk_init(struct platform_device *pdev)
         if (pdata->phy_mode != FSL_USB2_PHY_ULPI &&
             (freq < 59999000 || freq > 60001000)) {
                 dev_err(&pdev->dev, "USB_CLK=%lu, should be 60MHz\n", freq);
+                ret = -EINVAL;
                 goto eclkrate;
         }
 
@@ -66,9 +71,11 @@ eclkrate:
         clk_put(mxc_usb_clk);
         mxc_usb_clk = NULL;
 egusb:
-        clk_disable(mxc_ahb_clk);
+        if (!cpu_is_mx35())
+                clk_disable(mxc_ahb_clk);
 eenahb:
-        clk_put(mxc_ahb_clk);
+        if (!cpu_is_mx35())
+                clk_put(mxc_ahb_clk);
         return ret;
 }
 
@@ -90,6 +97,8 @@ void fsl_udc_clk_release(void)
                 clk_disable(mxc_usb_clk);
                 clk_put(mxc_usb_clk);
         }
-        clk_disable(mxc_ahb_clk);
-        clk_put(mxc_ahb_clk);
+        if (!cpu_is_mx35()) {
+                clk_disable(mxc_ahb_clk);
+                clk_put(mxc_ahb_clk);
+        }
 }
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index 7881f12413c4..3537d51073b2 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -2749,7 +2749,7 @@ static int __devexit qe_udc_remove(struct of_device *ofdev)
 }
 
 /*-------------------------------------------------------------------------*/
-static struct of_device_id __devinitdata qe_udc_match[] = {
+static const struct of_device_id qe_udc_match[] __devinitconst = {
         {
                 .compatible = "fsl,mpc8323-qe-usb",
                 .data = (void *)PORT_QE,
diff --git a/drivers/usb/gadget/fsl_qe_udc.h b/drivers/usb/gadget/fsl_qe_udc.h
index 31b2710882e4..bea5b827bebe 100644
--- a/drivers/usb/gadget/fsl_qe_udc.h
+++ b/drivers/usb/gadget/fsl_qe_udc.h
@@ -419,19 +419,4 @@ struct qe_udc {
 #define CPM_USB_RESTART_TX_OPCODE 0x0b
 #define CPM_USB_EP_SHIFT 5
 
-#ifndef CONFIG_CPM
-inline int cpm_command(u32 command, u8 opcode)
-{
-        return -EOPNOTSUPP;
-}
-#endif
-
-#ifndef CONFIG_QUICC_ENGINE
-inline int qe_issue_cmd(u32 cmd, u32 device, u8 mcn_protocol,
-        u32 cmd_input)
-{
-        return -EOPNOTSUPP;
-}
-#endif
-
 #endif  /* __FSL_QE_UDC_H */
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index f2d270b202f2..e511fec9f26d 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -45,46 +45,18 @@
 #define gadget_is_goku(g)       0
 #endif
 
-/* SH3 UDC -- not yet ported 2.4 --> 2.6 */
-#ifdef CONFIG_USB_GADGET_SUPERH
-#define gadget_is_sh(g)         !strcmp("sh_udc", (g)->name)
-#else
-#define gadget_is_sh(g)         0
-#endif
-
-/* not yet stable on 2.6 (would help "original Zaurus") */
-#ifdef CONFIG_USB_GADGET_SA1100
-#define gadget_is_sa1100(g)     !strcmp("sa1100_udc", (g)->name)
-#else
-#define gadget_is_sa1100(g)     0
-#endif
-
 #ifdef CONFIG_USB_GADGET_LH7A40X
 #define gadget_is_lh7a40x(g)    !strcmp("lh7a40x_udc", (g)->name)
 #else
 #define gadget_is_lh7a40x(g)    0
 #endif
 
-/* handhelds.org tree (?) */
-#ifdef CONFIG_USB_GADGET_MQ11XX
-#define gadget_is_mq11xx(g)     !strcmp("mq11xx_udc", (g)->name)
-#else
-#define gadget_is_mq11xx(g)     0
-#endif
-
 #ifdef CONFIG_USB_GADGET_OMAP
 #define gadget_is_omap(g)       !strcmp("omap_udc", (g)->name)
 #else
 #define gadget_is_omap(g)       0
 #endif
 
-/* not yet ported 2.4 --> 2.6 */
-#ifdef CONFIG_USB_GADGET_N9604
-#define gadget_is_n9604(g)      !strcmp("n9604_udc", (g)->name)
-#else
-#define gadget_is_n9604(g)      0
-#endif
-
 /* various unstable versions available */
 #ifdef CONFIG_USB_GADGET_PXA27X
 #define gadget_is_pxa27x(g)     !strcmp("pxa27x_udc", (g)->name)
@@ -122,14 +94,6 @@
 #define gadget_is_fsl_usb2(g)   0
 #endif
 
-/* Mentor high speed function controller */
-/* from Montavista kernel (?) */
-#ifdef CONFIG_USB_GADGET_MUSBHSFC
-#define gadget_is_musbhsfc(g)   !strcmp("musbhsfc_udc", (g)->name)
-#else
-#define gadget_is_musbhsfc(g)   0
-#endif
-
 /* Mentor high speed "dual role" controller, in peripheral role */
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
 #define gadget_is_musbhdrc(g)   !strcmp("musb_hdrc", (g)->name)
@@ -143,13 +107,6 @@
 #define gadget_is_langwell(g)   0
 #endif
 
-/* from Montavista kernel (?) */
-#ifdef CONFIG_USB_GADGET_MPC8272
-#define gadget_is_mpc8272(g)    !strcmp("mpc8272_udc", (g)->name)
-#else
-#define gadget_is_mpc8272(g)    0
-#endif
-
 #ifdef CONFIG_USB_GADGET_M66592
 #define gadget_is_m66592(g)     !strcmp("m66592_udc", (g)->name)
 #else
@@ -179,6 +136,12 @@
 #define gadget_is_r8a66597(g)   0
 #endif
 
+#ifdef CONFIG_USB_S3C_HSOTG
+#define gadget_is_s3c_hsotg(g)    (!strcmp("s3c-hsotg", (g)->name))
+#else
+#define gadget_is_s3c_hsotg(g)    0
+#endif
+
 
 /**
  * usb_gadget_controller_number - support bcdDevice id convention
@@ -203,20 +166,12 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x02;
         else if (gadget_is_pxa(gadget))
                 return 0x03;
-        else if (gadget_is_sh(gadget))
-                return 0x04;
-        else if (gadget_is_sa1100(gadget))
-                return 0x05;
         else if (gadget_is_goku(gadget))
                 return 0x06;
-        else if (gadget_is_mq11xx(gadget))
-                return 0x07;
         else if (gadget_is_omap(gadget))
                 return 0x08;
         else if (gadget_is_lh7a40x(gadget))
                 return 0x09;
-        else if (gadget_is_n9604(gadget))
-                return 0x10;
         else if (gadget_is_pxa27x(gadget))
                 return 0x11;
         else if (gadget_is_s3c2410(gadget))
@@ -225,12 +180,8 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x13;
         else if (gadget_is_imx(gadget))
                 return 0x14;
-        else if (gadget_is_musbhsfc(gadget))
-                return 0x15;
         else if (gadget_is_musbhdrc(gadget))
                 return 0x16;
-        else if (gadget_is_mpc8272(gadget))
-                return 0x17;
         else if (gadget_is_atmel_usba(gadget))
                 return 0x18;
         else if (gadget_is_fsl_usb2(gadget))
@@ -247,6 +198,8 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x24;
         else if (gadget_is_r8a66597(gadget))
                 return 0x25;
+        else if (gadget_is_s3c_hsotg(gadget))
+                return 0x26;
         return -ENOENT;
 }
 
@@ -265,10 +218,6 @@ static inline bool gadget_supports_altsettings(struct usb_gadget *gadget)
         if (gadget_is_pxa27x(gadget))
                 return false;
 
-        /* SH3 hardware just doesn't do altsettings */
-        if (gadget_is_sh(gadget))
-                return false;
-
         /* Everything else is *presumably* fine ... */
         return true;
 }
diff --git a/drivers/usb/gadget/gmidi.c b/drivers/usb/gadget/gmidi.c
index d0b1e836f0e0..2b56ce621852 100644
--- a/drivers/usb/gadget/gmidi.c
+++ b/drivers/usb/gadget/gmidi.c
@@ -21,6 +21,7 @@
 /* #define VERBOSE_DEBUG */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/utsname.h>
 #include <linux/device.h>
 
@@ -237,7 +238,7 @@ static const struct usb_interface_descriptor ac_interface_desc = {
 };
 
 /* B.3.2  Class-Specific AC Interface Descriptor */
-static const struct uac_ac_header_descriptor_1 ac_header_desc = {
+static const struct uac_ac_header_descriptor_v1_1 ac_header_desc = {
         .bLength =              UAC_DT_AC_HEADER_SIZE(1),
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubtype =   USB_MS_HEADER,
@@ -618,11 +619,6 @@ gmidi_set_config(struct gmidi_device *dev, unsigned number, gfp_t gfp_flags)
         }
 #endif
 
-        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;
-        }
         gmidi_reset_config(dev);
 
         switch (number) {
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 112bb40a427c..1088d08c7ed8 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -1768,7 +1768,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
          * usb_gadget_driver_{register,unregister}() must change.
          */
         if (the_controller) {
-                WARNING(dev, "ignoring %s\n", pci_name(pdev));
+                pr_warning("ignoring %s\n", pci_name(pdev));
                 return -EBUSY;
         }
         if (!pdev->irq) {
@@ -1859,7 +1859,7 @@ done:
 
 /*-------------------------------------------------------------------------*/
 
-static struct pci_device_id pci_ids [] = { {
+static const struct pci_device_id pci_ids[] = { {
         .class =        ((PCI_CLASS_SERIAL_USB << 8) | 0xfe),
         .class_mask =   ~0,
         .vendor =       0x102f,         /* Toshiba */
diff --git a/drivers/usb/gadget/imx_udc.c b/drivers/usb/gadget/imx_udc.c
index 01ee0b9bc957..e743122fcd93 100644
--- a/drivers/usb/gadget/imx_udc.c
+++ b/drivers/usb/gadget/imx_udc.c
@@ -29,6 +29,7 @@
 #include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/timer.h>
+#include <linux/slab.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index bf0f6520c6df..de8a83803505 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -194,7 +194,7 @@ enum ep_state {
 };
 
 struct ep_data {
-        struct semaphore                lock;
+        struct mutex                    lock;
         enum ep_state                   state;
         atomic_t                        count;
         struct dev_data                 *dev;
@@ -298,10 +298,10 @@ get_ready_ep (unsigned f_flags, struct ep_data *epdata)
         int     val;
 
         if (f_flags & O_NONBLOCK) {
-                if (down_trylock (&epdata->lock) != 0)
+                if (!mutex_trylock(&epdata->lock))
                         goto nonblock;
                 if (epdata->state != STATE_EP_ENABLED) {
-                        up (&epdata->lock);
+                        mutex_unlock(&epdata->lock);
 nonblock:
                         val = -EAGAIN;
                 } else
@@ -309,7 +309,8 @@ nonblock:
                 return val;
         }
 
-        if ((val = down_interruptible (&epdata->lock)) < 0)
+        val = mutex_lock_interruptible(&epdata->lock);
+        if (val < 0)
                 return val;
 
         switch (epdata->state) {
@@ -323,7 +324,7 @@ nonblock:
                 // FALLTHROUGH
         case STATE_EP_UNBOUND:                  /* clean disconnect */
                 val = -ENODEV;
-                up (&epdata->lock);
+                mutex_unlock(&epdata->lock);
         }
         return val;
 }
@@ -393,7 +394,7 @@ ep_read (struct file *fd, char __user *buf, size_t len, loff_t *ptr)
                 if (likely (data->ep != NULL))
                         usb_ep_set_halt (data->ep);
                 spin_unlock_irq (&data->dev->lock);
-                up (&data->lock);
+                mutex_unlock(&data->lock);
                 return -EBADMSG;
         }
 
@@ -411,7 +412,7 @@ ep_read (struct file *fd, char __user *buf, size_t len, loff_t *ptr)
                 value = -EFAULT;
 
 free1:
-        up (&data->lock);
+        mutex_unlock(&data->lock);
         kfree (kbuf);
         return value;
 }
@@ -436,7 +437,7 @@ ep_write (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
                 if (likely (data->ep != NULL))
                         usb_ep_set_halt (data->ep);
                 spin_unlock_irq (&data->dev->lock);
-                up (&data->lock);
+                mutex_unlock(&data->lock);
                 return -EBADMSG;
         }
 
@@ -455,7 +456,7 @@ ep_write (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
         VDEBUG (data->dev, "%s write %zu IN, status %d\n",
                 data->name, len, (int) value);
 free1:
-        up (&data->lock);
+        mutex_unlock(&data->lock);
         kfree (kbuf);
         return value;
 }
@@ -466,7 +467,8 @@ ep_release (struct inode *inode, struct file *fd)
         struct ep_data          *data = fd->private_data;
         int value;
 
-        if ((value = down_interruptible(&data->lock)) < 0)
+        value = mutex_lock_interruptible(&data->lock);
+        if (value < 0)
                 return value;
 
         /* clean up if this can be reopened */
@@ -476,7 +478,7 @@ ep_release (struct inode *inode, struct file *fd)
                 data->hs_desc.bDescriptorType = 0;
                 usb_ep_disable(data->ep);
         }
-        up (&data->lock);
+        mutex_unlock(&data->lock);
         put_ep (data);
         return 0;
 }
@@ -507,7 +509,7 @@ static long ep_ioctl(struct file *fd, unsigned code, unsigned long value)
         } else
                 status = -ENODEV;
         spin_unlock_irq (&data->dev->lock);
-        up (&data->lock);
+        mutex_unlock(&data->lock);
         return status;
 }
 
@@ -673,7 +675,7 @@ fail:
                 value = -ENODEV;
         spin_unlock_irq(&epdata->dev->lock);
 
-        up(&epdata->lock);
+        mutex_unlock(&epdata->lock);
 
         if (unlikely(value)) {
                 kfree(priv);
@@ -765,7 +767,8 @@ ep_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
         u32                     tag;
         int                     value, length = len;
 
-        if ((value = down_interruptible (&data->lock)) < 0)
+        value = mutex_lock_interruptible(&data->lock);
+        if (value < 0)
                 return value;
 
         if (data->state != STATE_EP_READY) {
@@ -854,7 +857,7 @@ fail:
                 data->desc.bDescriptorType = 0;
                 data->hs_desc.bDescriptorType = 0;
         }
-        up (&data->lock);
+        mutex_unlock(&data->lock);
         return value;
 fail0:
         value = -EINVAL;
@@ -870,7 +873,7 @@ ep_open (struct inode *inode, struct file *fd)
         struct ep_data          *data = inode->i_private;
         int                     value = -EBUSY;
 
-        if (down_interruptible (&data->lock) != 0)
+        if (mutex_lock_interruptible(&data->lock) != 0)
                 return -EINTR;
         spin_lock_irq (&data->dev->lock);
         if (data->dev->state == STATE_DEV_UNBOUND)
@@ -885,7 +888,7 @@ ep_open (struct inode *inode, struct file *fd)
                 DBG (data->dev, "%s state %d\n",
                         data->name, data->state);
         spin_unlock_irq (&data->dev->lock);
-        up (&data->lock);
+        mutex_unlock(&data->lock);
         return value;
 }
 
@@ -1631,7 +1634,7 @@ static int activate_ep_files (struct dev_data *dev)
                 if (!data)
                         goto enomem0;
                 data->state = STATE_EP_DISABLED;
-                init_MUTEX (&data->lock);
+                mutex_init(&data->lock);
                 init_waitqueue_head (&data->wait);
 
                 strncpy (data->name, ep->name, sizeof (data->name) - 1);
diff --git a/drivers/usb/gadget/lh7a40x_udc.c b/drivers/usb/gadget/lh7a40x_udc.c
index 6cd3d54f5640..fded3fca793b 100644
--- a/drivers/usb/gadget/lh7a40x_udc.c
+++ b/drivers/usb/gadget/lh7a40x_udc.c
@@ -22,6 +22,7 @@
  */
 
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #include "lh7a40x_udc.h"
 
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index a8c8543d1b08..166bf71fd348 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -25,6 +25,7 @@
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
diff --git a/drivers/usb/gadget/mass_storage.c b/drivers/usb/gadget/mass_storage.c
new file mode 100644
index 000000000000..705cc1f76327
--- /dev/null
+++ b/drivers/usb/gadget/mass_storage.c
@@ -0,0 +1,246 @@
+/*
+ * mass_storage.c -- Mass Storage USB Gadget
+ *
+ * Copyright (C) 2003-2008 Alan Stern
+ * Copyright (C) 2009 Samsung Electronics
+ *                    Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License 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
+ */
+
+
+/*
+ * The Mass Storage Gadget acts as a USB Mass Storage device,
+ * appearing to the host as a disk drive or as a CD-ROM drive.  In
+ * addition to providing an example of a genuinely useful gadget
+ * driver for a USB device, it also illustrates a technique of
+ * double-buffering for increased throughput.  Last but not least, it
+ * gives an easy way to probe the behavior of the Mass Storage drivers
+ * in a USB host.
+ *
+ * Since this file serves only administrative purposes and all the
+ * business logic is implemented in f_mass_storage.* file.  Read
+ * comments in this file for more detailed description.
+ */
+
+
+#include <linux/kernel.h>
+#include <linux/utsname.h>
+#include <linux/usb/ch9.h>
+
+
+/*-------------------------------------------------------------------------*/
+
+#define DRIVER_DESC             "Mass Storage Gadget"
+#define DRIVER_VERSION          "2009/09/11"
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * kbuild is not very cooperative with respect to linking separately
+ * compiled library objects into one module.  So for now we won't use
+ * separate compilation ... ensuring init/exit sections work to shrink
+ * the runtime footprint, and giving us at least some parts of what
+ * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
+ */
+
+#include "composite.c"
+#include "usbstring.c"
+#include "config.c"
+#include "epautoconf.c"
+#include "f_mass_storage.c"
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_device_descriptor msg_device_desc = {
+        .bLength =              sizeof msg_device_desc,
+        .bDescriptorType =      USB_DT_DEVICE,
+
+        .bcdUSB =               cpu_to_le16(0x0200),
+        .bDeviceClass =         USB_CLASS_PER_INTERFACE,
+
+        /* Vendor and product id can be overridden by module parameters.  */
+        .idVendor =             cpu_to_le16(FSG_VENDOR_ID),
+        .idProduct =            cpu_to_le16(FSG_PRODUCT_ID),
+        /* .bcdDevice = f(hardware) */
+        /* .iManufacturer = DYNAMIC */
+        /* .iProduct = DYNAMIC */
+        /* NO SERIAL NUMBER */
+        .bNumConfigurations =   1,
+};
+
+static struct usb_otg_descriptor otg_descriptor = {
+        .bLength =              sizeof otg_descriptor,
+        .bDescriptorType =      USB_DT_OTG,
+
+        /* REVISIT SRP-only hardware is possible, although
+         * it would not be called "OTG" ...
+         */
+        .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
+};
+
+static const struct usb_descriptor_header *otg_desc[] = {
+        (struct usb_descriptor_header *) &otg_descriptor,
+        NULL,
+};
+
+
+/* string IDs are assigned dynamically */
+
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
+#define STRING_CONFIGURATION_IDX        2
+
+static char manufacturer[50];
+
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer,
+        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        [STRING_CONFIGURATION_IDX].s = "Self Powered",
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_dev = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_dev,
+};
+
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
+        NULL,
+};
+
+
+
+/****************************** Configurations ******************************/
+
+static struct fsg_module_parameters mod_data = {
+        .stall = 1
+};
+FSG_MODULE_PARAMETERS(/* no prefix */, mod_data);
+
+static unsigned long msg_registered = 0;
+static void msg_cleanup(void);
+
+static int msg_thread_exits(struct fsg_common *common)
+{
+        msg_cleanup();
+        return 0;
+}
+
+static int __init msg_do_config(struct usb_configuration *c)
+{
+        struct fsg_common *common;
+        struct fsg_config config;
+        int ret;
+
+        if (gadget_is_otg(c->cdev->gadget)) {
+                c->descriptors = otg_desc;
+                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+        }
+
+        fsg_config_from_params(&config, &mod_data);
+        config.thread_exits = msg_thread_exits;
+        common = fsg_common_init(0, c->cdev, &config);
+        if (IS_ERR(common))
+                return PTR_ERR(common);
+
+        ret = fsg_add(c->cdev, c, common);
+        fsg_common_put(common);
+        return ret;
+}
+
+static struct usb_configuration msg_config_driver = {
+        .label                  = "Linux File-Backed Storage",
+        .bind                   = msg_do_config,
+        .bConfigurationValue    = 1,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
+};
+
+
+
+/****************************** Gadget Bind ******************************/
+
+
+static int __init msg_bind(struct usb_composite_dev *cdev)
+{
+        struct usb_gadget *gadget = cdev->gadget;
+        int status;
+
+        /* Allocate string descriptor numbers ... note that string
+         * contents can be overridden by the composite_dev glue.
+         */
+
+        /* device descriptor strings: manufacturer, product */
+        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+                 init_utsname()->sysname, init_utsname()->release,
+                 gadget->name);
+        status = usb_string_id(cdev);
+        if (status < 0)
+                return status;
+        strings_dev[STRING_MANUFACTURER_IDX].id = status;
+        msg_device_desc.iManufacturer = status;
+
+        status = usb_string_id(cdev);
+        if (status < 0)
+                return status;
+        strings_dev[STRING_PRODUCT_IDX].id = status;
+        msg_device_desc.iProduct = status;
+
+        status = usb_string_id(cdev);
+        if (status < 0)
+                return status;
+        strings_dev[STRING_CONFIGURATION_IDX].id = status;
+        msg_config_driver.iConfiguration = status;
+
+        /* register our second configuration */
+        status = usb_add_config(cdev, &msg_config_driver);
+        if (status < 0)
+                return status;
+
+        dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
+        set_bit(0, &msg_registered);
+        return 0;
+}
+
+
+/****************************** Some noise ******************************/
+
+
+static struct usb_composite_driver msg_driver = {
+        .name           = "g_mass_storage",
+        .dev            = &msg_device_desc,
+        .strings        = dev_strings,
+        .bind           = msg_bind,
+};
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Michal Nazarewicz");
+MODULE_LICENSE("GPL");
+
+static int __init msg_init(void)
+{
+        return usb_composite_register(&msg_driver);
+}
+module_init(msg_init);
+
+static void msg_cleanup(void)
+{
+        if (test_and_clear_bit(0, &msg_registered))
+                usb_composite_unregister(&msg_driver);
+}
+module_exit(msg_cleanup);
diff --git a/drivers/usb/gadget/multi.c b/drivers/usb/gadget/multi.c
new file mode 100644
index 000000000000..a930d7fd7e7a
--- /dev/null
+++ b/drivers/usb/gadget/multi.c
@@ -0,0 +1,356 @@
+/*
+ * multi.c -- Multifunction Composite driver
+ *
+ * Copyright (C) 2008 David Brownell
+ * Copyright (C) 2008 Nokia Corporation
+ * Copyright (C) 2009 Samsung Electronics
+ * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#include <linux/kernel.h>
+#include <linux/utsname.h>
+
+
+#if defined USB_ETH_RNDIS
+#  undef USB_ETH_RNDIS
+#endif
+#ifdef CONFIG_USB_G_MULTI_RNDIS
+#  define USB_ETH_RNDIS y
+#endif
+
+
+#define DRIVER_DESC             "Multifunction Composite Gadget"
+#define DRIVER_VERSION          "2009/07/21"
+
+/*-------------------------------------------------------------------------*/
+
+#define MULTI_VENDOR_NUM        0x0525  /* XXX NetChip */
+#define MULTI_PRODUCT_NUM       0xa4ab  /* XXX */
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * kbuild is not very cooperative with respect to linking separately
+ * compiled library objects into one module.  So for now we won't use
+ * separate compilation ... ensuring init/exit sections work to shrink
+ * the runtime footprint, and giving us at least some parts of what
+ * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
+ */
+
+#include "composite.c"
+#include "usbstring.c"
+#include "config.c"
+#include "epautoconf.c"
+
+#include "u_serial.c"
+#include "f_acm.c"
+
+#include "f_ecm.c"
+#include "f_subset.c"
+#ifdef USB_ETH_RNDIS
+#  include "f_rndis.c"
+#  include "rndis.c"
+#endif
+#include "u_ether.c"
+
+#undef DBG     /* u_ether.c has broken idea about macros */
+#undef VDBG    /* so clean up after it */
+#undef ERROR
+#undef INFO
+#include "f_mass_storage.c"
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_device_descriptor device_desc = {
+        .bLength =              sizeof device_desc,
+        .bDescriptorType =      USB_DT_DEVICE,
+
+        .bcdUSB =               cpu_to_le16(0x0200),
+
+        /* .bDeviceClass =              USB_CLASS_COMM, */
+        /* .bDeviceSubClass =   0, */
+        /* .bDeviceProtocol =   0, */
+        .bDeviceClass =         0xEF,
+        .bDeviceSubClass =      2,
+        .bDeviceProtocol =      1,
+        /* .bMaxPacketSize0 = f(hardware) */
+
+        /* Vendor and product id can be overridden by module parameters.  */
+        .idVendor =             cpu_to_le16(MULTI_VENDOR_NUM),
+        .idProduct =            cpu_to_le16(MULTI_PRODUCT_NUM),
+        /* .bcdDevice = f(hardware) */
+        /* .iManufacturer = DYNAMIC */
+        /* .iProduct = DYNAMIC */
+        /* NO SERIAL NUMBER */
+        .bNumConfigurations =   1,
+};
+
+static struct usb_otg_descriptor otg_descriptor = {
+        .bLength =              sizeof otg_descriptor,
+        .bDescriptorType =      USB_DT_OTG,
+
+        /* REVISIT SRP-only hardware is possible, although
+         * it would not be called "OTG" ...
+         */
+        .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
+};
+
+static const struct usb_descriptor_header *otg_desc[] = {
+        (struct usb_descriptor_header *) &otg_descriptor,
+        NULL,
+};
+
+
+/* string IDs are assigned dynamically */
+
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
+
+static char manufacturer[50];
+
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer,
+        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_dev = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_dev,
+};
+
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
+        NULL,
+};
+
+static u8 hostaddr[ETH_ALEN];
+
+
+
+/****************************** Configurations ******************************/
+
+static struct fsg_module_parameters mod_data = {
+        .stall = 1
+};
+FSG_MODULE_PARAMETERS(/* no prefix */, mod_data);
+
+static struct fsg_common *fsg_common;
+
+
+#ifdef USB_ETH_RNDIS
+
+static int __init rndis_do_config(struct usb_configuration *c)
+{
+        int ret;
+
+        if (gadget_is_otg(c->cdev->gadget)) {
+                c->descriptors = otg_desc;
+                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+        }
+
+        ret = rndis_bind_config(c, hostaddr);
+        if (ret < 0)
+                return ret;
+
+        ret = acm_bind_config(c, 0);
+        if (ret < 0)
+                return ret;
+
+        ret = fsg_add(c->cdev, c, fsg_common);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static struct usb_configuration rndis_config_driver = {
+        .label                  = "Multifunction Composite (RNDIS + MS + ACM)",
+        .bind                   = rndis_do_config,
+        .bConfigurationValue    = 2,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
+};
+
+#endif
+
+#ifdef CONFIG_USB_G_MULTI_CDC
+
+static int __init cdc_do_config(struct usb_configuration *c)
+{
+        int ret;
+
+        if (gadget_is_otg(c->cdev->gadget)) {
+                c->descriptors = otg_desc;
+                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+        }
+
+        ret = ecm_bind_config(c, hostaddr);
+        if (ret < 0)
+                return ret;
+
+        ret = acm_bind_config(c, 0);
+        if (ret < 0)
+                return ret;
+
+        ret = fsg_add(c->cdev, c, fsg_common);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static struct usb_configuration cdc_config_driver = {
+        .label                  = "Multifunction Composite (CDC + MS + ACM)",
+        .bind                   = cdc_do_config,
+        .bConfigurationValue    = 1,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
+};
+
+#endif
+
+
+
+/****************************** Gadget Bind ******************************/
+
+
+static int __init multi_bind(struct usb_composite_dev *cdev)
+{
+        struct usb_gadget *gadget = cdev->gadget;
+        int status, gcnum;
+
+        if (!can_support_ecm(cdev->gadget)) {
+                dev_err(&gadget->dev, "controller '%s' not usable\n",
+                        gadget->name);
+                return -EINVAL;
+        }
+
+        /* set up network link layer */
+        status = gether_setup(cdev->gadget, hostaddr);
+        if (status < 0)
+                return status;
+
+        /* set up serial link layer */
+        status = gserial_setup(cdev->gadget, 1);
+        if (status < 0)
+                goto fail0;
+
+        /* set up mass storage function */
+        fsg_common = fsg_common_from_params(0, cdev, &mod_data);
+        if (IS_ERR(fsg_common)) {
+                status = PTR_ERR(fsg_common);
+                goto fail1;
+        }
+
+
+        gcnum = usb_gadget_controller_number(gadget);
+        if (gcnum >= 0)
+                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
+        else {
+                /* We assume that can_support_ecm() tells the truth;
+                 * but if the controller isn't recognized at all then
+                 * that assumption is a bit more likely to be wrong.
+                 */
+                WARNING(cdev, "controller '%s' not recognized\n",
+                        gadget->name);
+                device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099);
+        }
+
+
+        /* Allocate string descriptor numbers ... note that string
+         * contents can be overridden by the composite_dev glue.
+         */
+
+        /* device descriptor strings: manufacturer, product */
+        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+                 init_utsname()->sysname, init_utsname()->release,
+                 gadget->name);
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail2;
+        strings_dev[STRING_MANUFACTURER_IDX].id = status;
+        device_desc.iManufacturer = status;
+
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail2;
+        strings_dev[STRING_PRODUCT_IDX].id = status;
+        device_desc.iProduct = status;
+
+#ifdef USB_ETH_RNDIS
+        /* register our first configuration */
+        status = usb_add_config(cdev, &rndis_config_driver);
+        if (status < 0)
+                goto fail2;
+#endif
+
+#ifdef CONFIG_USB_G_MULTI_CDC
+        /* register our second configuration */
+        status = usb_add_config(cdev, &cdc_config_driver);
+        if (status < 0)
+                goto fail2;
+#endif
+
+        dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
+        fsg_common_put(fsg_common);
+        return 0;
+
+fail2:
+        fsg_common_put(fsg_common);
+fail1:
+        gserial_cleanup();
+fail0:
+        gether_cleanup();
+        return status;
+}
+
+static int __exit multi_unbind(struct usb_composite_dev *cdev)
+{
+        gserial_cleanup();
+        gether_cleanup();
+        return 0;
+}
+
+
+/****************************** Some noise ******************************/
+
+
+static struct usb_composite_driver multi_driver = {
+        .name           = "g_multi",
+        .dev            = &device_desc,
+        .strings        = dev_strings,
+        .bind           = multi_bind,
+        .unbind         = __exit_p(multi_unbind),
+};
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Michal Nazarewicz");
+MODULE_LICENSE("GPL");
+
+static int __init g_multi_init(void)
+{
+        return usb_composite_register(&multi_driver);
+}
+module_init(g_multi_init);
+
+static void __exit g_multi_cleanup(void)
+{
+        usb_composite_unregister(&multi_driver);
+}
+module_exit(g_multi_cleanup);
diff --git a/drivers/usb/gadget/nokia.c b/drivers/usb/gadget/nokia.c
new file mode 100644
index 000000000000..7d6b66a85724
--- /dev/null
+++ b/drivers/usb/gadget/nokia.c
@@ -0,0 +1,259 @@
+/*
+ * nokia.c -- Nokia Composite Gadget Driver
+ *
+ * Copyright (C) 2008-2010 Nokia Corporation
+ * Contact: Felipe Balbi <felipe.balbi@nokia.com>
+ *
+ * This gadget driver borrows from serial.c which is:
+ *
+ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
+ * Copyright (C) 2008 by David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * This software is distributed under the terms of the GNU General
+ * Public License ("GPL") as published by the Free Software Foundation,
+ * version 2 of that License.
+ */
+
+#include <linux/kernel.h>
+#include <linux/utsname.h>
+#include <linux/device.h>
+
+#include "u_serial.h"
+#include "u_ether.h"
+#include "u_phonet.h"
+#include "gadget_chips.h"
+
+/* Defines */
+
+#define NOKIA_VERSION_NUM               0x0211
+#define NOKIA_LONG_NAME                 "N900 (PC-Suite Mode)"
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Kbuild is not very cooperative with respect to linking separately
+ * compiled library objects into one module.  So for now we won't use
+ * separate compilation ... ensuring init/exit sections work to shrink
+ * the runtime footprint, and giving us at least some parts of what
+ * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
+ */
+#include "composite.c"
+#include "usbstring.c"
+#include "config.c"
+#include "epautoconf.c"
+
+#include "u_serial.c"
+#include "f_acm.c"
+#include "f_ecm.c"
+#include "f_obex.c"
+#include "f_serial.c"
+#include "f_phonet.c"
+#include "u_ether.c"
+
+/*-------------------------------------------------------------------------*/
+
+#define NOKIA_VENDOR_ID                 0x0421  /* Nokia */
+#define NOKIA_PRODUCT_ID                0x01c8  /* Nokia Gadget */
+
+/* string IDs are assigned dynamically */
+
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
+#define STRING_DESCRIPTION_IDX          2
+
+static char manufacturer_nokia[] = "Nokia";
+static const char product_nokia[] = NOKIA_LONG_NAME;
+static const char description_nokia[] = "PC-Suite Configuration";
+
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer_nokia,
+        [STRING_PRODUCT_IDX].s = NOKIA_LONG_NAME,
+        [STRING_DESCRIPTION_IDX].s = description_nokia,
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_dev = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_dev,
+};
+
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
+        NULL,
+};
+
+static struct usb_device_descriptor device_desc = {
+        .bLength                = USB_DT_DEVICE_SIZE,
+        .bDescriptorType        = USB_DT_DEVICE,
+        .bcdUSB                 = __constant_cpu_to_le16(0x0200),
+        .bDeviceClass           = USB_CLASS_COMM,
+        .idVendor               = __constant_cpu_to_le16(NOKIA_VENDOR_ID),
+        .idProduct              = __constant_cpu_to_le16(NOKIA_PRODUCT_ID),
+        /* .iManufacturer = DYNAMIC */
+        /* .iProduct = DYNAMIC */
+        .bNumConfigurations =   1,
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Module */
+MODULE_DESCRIPTION("Nokia composite gadget driver for N900");
+MODULE_AUTHOR("Felipe Balbi");
+MODULE_LICENSE("GPL");
+
+/*-------------------------------------------------------------------------*/
+
+static u8 hostaddr[ETH_ALEN];
+
+static int __init nokia_bind_config(struct usb_configuration *c)
+{
+        int status = 0;
+
+        status = phonet_bind_config(c);
+        if (status)
+                printk(KERN_DEBUG "could not bind phonet config\n");
+
+        status = obex_bind_config(c, 0);
+        if (status)
+                printk(KERN_DEBUG "could not bind obex config %d\n", 0);
+
+        status = obex_bind_config(c, 1);
+        if (status)
+                printk(KERN_DEBUG "could not bind obex config %d\n", 0);
+
+        status = acm_bind_config(c, 2);
+        if (status)
+                printk(KERN_DEBUG "could not bind acm config\n");
+
+        status = ecm_bind_config(c, hostaddr);
+        if (status)
+                printk(KERN_DEBUG "could not bind ecm config\n");
+
+        return status;
+}
+
+static struct usb_configuration nokia_config_500ma_driver = {
+        .label          = "Bus Powered",
+        .bind           = nokia_bind_config,
+        .bConfigurationValue = 1,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes   = USB_CONFIG_ATT_ONE,
+        .bMaxPower      = 250, /* 500mA */
+};
+
+static struct usb_configuration nokia_config_100ma_driver = {
+        .label          = "Self Powered",
+        .bind           = nokia_bind_config,
+        .bConfigurationValue = 2,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes   = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+        .bMaxPower      = 50, /* 100 mA */
+};
+
+static int __init nokia_bind(struct usb_composite_dev *cdev)
+{
+        int                     gcnum;
+        struct usb_gadget       *gadget = cdev->gadget;
+        int                     status;
+
+        status = gphonet_setup(cdev->gadget);
+        if (status < 0)
+                goto err_phonet;
+
+        status = gserial_setup(cdev->gadget, 3);
+        if (status < 0)
+                goto err_serial;
+
+        status = gether_setup(cdev->gadget, hostaddr);
+        if (status < 0)
+                goto err_ether;
+
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto err_usb;
+        strings_dev[STRING_MANUFACTURER_IDX].id = status;
+
+        device_desc.iManufacturer = status;
+
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto err_usb;
+        strings_dev[STRING_PRODUCT_IDX].id = status;
+
+        device_desc.iProduct = status;
+
+        /* config description */
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto err_usb;
+        strings_dev[STRING_DESCRIPTION_IDX].id = status;
+
+        nokia_config_500ma_driver.iConfiguration = status;
+        nokia_config_100ma_driver.iConfiguration = status;
+
+        /* set up other descriptors */
+        gcnum = usb_gadget_controller_number(gadget);
+        if (gcnum >= 0)
+                device_desc.bcdDevice = cpu_to_le16(NOKIA_VERSION_NUM);
+        else {
+                /* this should only work with hw that supports altsettings
+                 * and several endpoints, anything else, panic.
+                 */
+                pr_err("nokia_bind: controller '%s' not recognized\n",
+                        gadget->name);
+                goto err_usb;
+        }
+
+        /* finaly register the configuration */
+        status = usb_add_config(cdev, &nokia_config_500ma_driver);
+        if (status < 0)
+                goto err_usb;
+
+        status = usb_add_config(cdev, &nokia_config_100ma_driver);
+        if (status < 0)
+                goto err_usb;
+
+        dev_info(&gadget->dev, "%s\n", NOKIA_LONG_NAME);
+
+        return 0;
+
+err_usb:
+        gether_cleanup();
+err_ether:
+        gserial_cleanup();
+err_serial:
+        gphonet_cleanup();
+err_phonet:
+        return status;
+}
+
+static int __exit nokia_unbind(struct usb_composite_dev *cdev)
+{
+        gphonet_cleanup();
+        gserial_cleanup();
+        gether_cleanup();
+
+        return 0;
+}
+
+static struct usb_composite_driver nokia_driver = {
+        .name           = "g_nokia",
+        .dev            = &device_desc,
+        .strings        = dev_strings,
+        .bind           = nokia_bind,
+        .unbind         = __exit_p(nokia_unbind),
+};
+
+static int __init nokia_init(void)
+{
+        return usb_composite_register(&nokia_driver);
+}
+module_init(nokia_init);
+
+static void __exit nokia_cleanup(void)
+{
+        usb_composite_unregister(&nokia_driver);
+}
+module_exit(nokia_cleanup);
+
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index a2db0e174f2c..f81e4f025f23 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -52,9 +52,9 @@
 #include <asm/unaligned.h>
 #include <asm/mach-types.h>
 
-#include <mach/dma.h>
-#include <mach/usb.h>
-#include <mach/control.h>
+#include <plat/dma.h>
+#include <plat/usb.h>
+#include <plat/control.h>
 
 #include "omap_udc.h"
 
@@ -2098,6 +2098,7 @@ static inline int machine_without_vbus_sense(void)
                 || machine_is_omap_h4()
 #endif
                 || machine_is_sx1()
+                || cpu_is_omap7xx() /* No known omap7xx boards with vbus sense */
                 );
 }
 
@@ -2838,6 +2839,16 @@ static int __init omap_udc_probe(struct platform_device *pdev)
                 udelay(100);
         }
 
+        if (cpu_is_omap7xx()) {
+                dc_clk = clk_get(&pdev->dev, "usb_dc_ck");
+                hhc_clk = clk_get(&pdev->dev, "l3_ocpi_ck");
+                BUG_ON(IS_ERR(dc_clk) || IS_ERR(hhc_clk));
+                /* can't use omap_udc_enable_clock yet */
+                clk_enable(dc_clk);
+                clk_enable(hhc_clk);
+                udelay(100);
+        }
+
         INFO("OMAP UDC rev %d.%d%s\n",
                 omap_readw(UDC_REV) >> 4, omap_readw(UDC_REV) & 0xf,
                 config->otg ? ", Mini-AB" : "");
@@ -2970,7 +2981,7 @@ known:
                 goto cleanup3;
         }
 #endif
-        if (cpu_is_omap16xx()) {
+        if (cpu_is_omap16xx() || cpu_is_omap7xx()) {
                 udc->dc_clk = dc_clk;
                 udc->hhc_clk = hhc_clk;
                 clk_disable(hhc_clk);
@@ -3008,7 +3019,7 @@ cleanup0:
         if (xceiv)
                 otg_put_transceiver(xceiv);
 
-        if (cpu_is_omap16xx() || cpu_is_omap24xx()) {
+        if (cpu_is_omap16xx() || cpu_is_omap24xx() || cpu_is_omap7xx()) {
                 clk_disable(hhc_clk);
                 clk_disable(dc_clk);
                 clk_put(hhc_clk);
@@ -3115,6 +3126,10 @@ static struct platform_driver udc_driver = {
 
 static int __init udc_init(void)
 {
+        /* Disable DMA for omap7xx -- it doesn't work right. */
+        if (cpu_is_omap7xx())
+                use_dma = 0;
+
         INFO("%s, version: " DRIVER_VERSION
 #ifdef  USE_ISO
                 " (iso)"
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index 2d867fd22413..6b8bf8c781c4 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -949,12 +949,6 @@ printer_set_config(struct printer_dev *dev, unsigned number)
         int                     result = 0;
         struct usb_gadget       *gadget = dev->gadget;
 
-        if (gadget_is_sa1100(gadget) && dev->config) {
-                /* tx fifo is full, but we can't clear it...*/
-                INFO(dev, "can't change configurations\n");
-                return -ESPIPE;
-        }
-
         switch (number) {
         case DEV_CONFIG_VALUE:
                 result = 0;
@@ -1033,12 +1027,6 @@ set_interface(struct printer_dev *dev, unsigned number)
 {
         int                     result = 0;
 
-        if (gadget_is_sa1100(dev->gadget) && dev->interface < 0) {
-                /* tx fifo is full, but we can't clear it...*/
-                INFO(dev, "can't change interfaces\n");
-                return -ESPIPE;
-        }
-
         /* Free the current interface */
         switch (dev->interface) {
         case PRINTER_INTERFACE:
@@ -1392,12 +1380,6 @@ printer_bind(struct usb_gadget *gadget)
                 goto fail;
         }
 
-        if (gadget_is_sa1100(gadget)) {
-                /* hardware can't write zero length packets. */
-                ERROR(dev, "SA1100 controller is unsupport by this driver\n");
-                goto fail;
-        }
-
         gcnum = usb_gadget_controller_number(gadget);
         if (gcnum >= 0) {
                 device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index e6fedbd5a654..be5fb34d9602 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -65,6 +65,10 @@
 #include <mach/pxa25x-udc.h>
 #endif
 
+#ifdef CONFIG_ARCH_LUBBOCK
+#include <mach/lubbock.h>
+#endif
+
 #include <asm/mach/udc_pxa2xx.h>
 
 
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index 1937d8c7b433..85b0d8921eae 100644
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -31,6 +31,7 @@
 #include <linux/clk.h>
 #include <linux/irq.h>
 #include <linux/gpio.h>
+#include <linux/slab.h>
 
 #include <asm/byteorder.h>
 #include <mach/hardware.h>
@@ -742,13 +743,17 @@ static void ep_del_request(struct pxa_ep *ep, struct pxa27x_request *req)
  * @ep: pxa physical endpoint
  * @req: pxa request
  * @status: usb request status sent to gadget API
+ * @pflags: flags of previous spinlock_irq_save() or NULL if no lock held
  *
- * Context: ep->lock held
+ * Context: ep->lock held if flags not NULL, else ep->lock released
  *
  * Retire a pxa27x usb request. Endpoint must be locked.
  */
-static void req_done(struct pxa_ep *ep, struct pxa27x_request *req, int status)
+static void req_done(struct pxa_ep *ep, struct pxa27x_request *req, int status,
+        unsigned long *pflags)
 {
+        unsigned long   flags;
+
         ep_del_request(ep, req);
         if (likely(req->req.status == -EINPROGRESS))
                 req->req.status = status;
@@ -760,38 +765,48 @@ static void req_done(struct pxa_ep *ep, struct pxa27x_request *req, int status)
                         &req->req, status,
                         req->req.actual, req->req.length);
 
+        if (pflags)
+                spin_unlock_irqrestore(&ep->lock, *pflags);
+        local_irq_save(flags);
         req->req.complete(&req->udc_usb_ep->usb_ep, &req->req);
+        local_irq_restore(flags);
+        if (pflags)
+                spin_lock_irqsave(&ep->lock, *pflags);
 }
 
 /**
  * ep_end_out_req - Ends endpoint OUT request
  * @ep: physical endpoint
  * @req: pxa request
+ * @pflags: flags of previous spinlock_irq_save() or NULL if no lock held
  *
- * Context: ep->lock held
+ * Context: ep->lock held or released (see req_done())
  *
  * Ends endpoint OUT request (completes usb request).
  */
-static void ep_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req)
+static void ep_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req,
+        unsigned long *pflags)
 {
         inc_ep_stats_reqs(ep, !USB_DIR_IN);
-        req_done(ep, req, 0);
+        req_done(ep, req, 0, pflags);
 }
 
 /**
  * ep0_end_out_req - Ends control endpoint OUT request (ends data stage)
  * @ep: physical endpoint
  * @req: pxa request
+ * @pflags: flags of previous spinlock_irq_save() or NULL if no lock held
  *
- * Context: ep->lock held
+ * Context: ep->lock held or released (see req_done())
  *
  * Ends control endpoint OUT 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)
+static void ep0_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req,
+        unsigned long *pflags)
 {
         set_ep0state(ep->dev, OUT_STATUS_STAGE);
-        ep_end_out_req(ep, req);
+        ep_end_out_req(ep, req, pflags);
         ep0_idle(ep->dev);
 }
 
@@ -799,31 +814,35 @@ static void ep0_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req)
  * ep_end_in_req - Ends endpoint IN request
  * @ep: physical endpoint
  * @req: pxa request
+ * @pflags: flags of previous spinlock_irq_save() or NULL if no lock held
  *
- * Context: ep->lock held
+ * Context: ep->lock held or released (see req_done())
  *
  * Ends endpoint IN request (completes usb request).
  */
-static void ep_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req)
+static void ep_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req,
+        unsigned long *pflags)
 {
         inc_ep_stats_reqs(ep, USB_DIR_IN);
-        req_done(ep, req, 0);
+        req_done(ep, req, 0, pflags);
 }
 
 /**
  * ep0_end_in_req - Ends control endpoint IN request (ends data stage)
  * @ep: physical endpoint
  * @req: pxa request
+ * @pflags: flags of previous spinlock_irq_save() or NULL if no lock held
  *
- * Context: ep->lock held
+ * Context: ep->lock held or released (see req_done())
  *
  * Ends control endpoint IN 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)
+static void ep0_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req,
+        unsigned long *pflags)
 {
         set_ep0state(ep->dev, IN_STATUS_STAGE);
-        ep_end_in_req(ep, req);
+        ep_end_in_req(ep, req, pflags);
 }
 
 /**
@@ -831,19 +850,22 @@ static void ep0_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req)
  * @ep: pxa endpoint
  * @status: usb request status
  *
- * Context: ep->lock held
+ * Context: ep->lock released
  *
  * 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;
+        struct pxa27x_request   *req;
+        unsigned long           flags;
 
+        spin_lock_irqsave(&ep->lock, flags);
         while (!list_empty(&ep->queue)) {
                 req = list_entry(ep->queue.next, struct pxa27x_request, queue);
-                req_done(ep, req, status);
+                req_done(ep, req, status, &flags);
         }
+        spin_unlock_irqrestore(&ep->lock, flags);
 }
 
 /**
@@ -1123,6 +1145,7 @@ static int pxa_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
         int                     rc = 0;
         int                     is_first_req;
         unsigned                length;
+        int                     recursion_detected;
 
         req = container_of(_req, struct pxa27x_request, req);
         udc_usb_ep = container_of(_ep, struct udc_usb_ep, usb_ep);
@@ -1152,6 +1175,7 @@ static int pxa_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
                 return -EMSGSIZE;
 
         spin_lock_irqsave(&ep->lock, flags);
+        recursion_detected = ep->in_handle_ep;
 
         is_first_req = list_empty(&ep->queue);
         ep_dbg(ep, "queue req %p(first=%s), len %d buf %p\n",
@@ -1161,12 +1185,12 @@ static int pxa_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
         if (!ep->enabled) {
                 _req->status = -ESHUTDOWN;
                 rc = -ESHUTDOWN;
-                goto out;
+                goto out_locked;
         }
 
         if (req->in_use) {
                 ep_err(ep, "refusing to queue req %p (already queued)\n", req);
-                goto out;
+                goto out_locked;
         }
 
         length = _req->length;
@@ -1174,12 +1198,13 @@ static int pxa_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
         _req->actual = 0;
 
         ep_add_request(ep, req);
+        spin_unlock_irqrestore(&ep->lock, flags);
 
         if (is_ep0(ep)) {
                 switch (dev->ep0state) {
                 case WAIT_ACK_SET_CONF_INTERF:
                         if (length == 0) {
-                                ep_end_in_req(ep, req);
+                                ep_end_in_req(ep, req, NULL);
                         } else {
                                 ep_err(ep, "got a request of %d bytes while"
                                         "in state WAIT_ACK_SET_CONF_INTERF\n",
@@ -1192,12 +1217,12 @@ static int pxa_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
                 case IN_DATA_STAGE:
                         if (!ep_is_full(ep))
                                 if (write_ep0_fifo(ep, req))
-                                        ep0_end_in_req(ep, req);
+                                        ep0_end_in_req(ep, req, NULL);
                         break;
                 case OUT_DATA_STAGE:
                         if ((length == 0) || !epout_has_pkt(ep))
                                 if (read_ep0_fifo(ep, req))
-                                        ep0_end_out_req(ep, req);
+                                        ep0_end_out_req(ep, req, NULL);
                         break;
                 default:
                         ep_err(ep, "odd state %s to send me a request\n",
@@ -1207,12 +1232,15 @@ static int pxa_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
                         break;
                 }
         } else {
-                handle_ep(ep);
+                if (!recursion_detected)
+                        handle_ep(ep);
         }
 
 out:
-        spin_unlock_irqrestore(&ep->lock, flags);
         return rc;
+out_locked:
+        spin_unlock_irqrestore(&ep->lock, flags);
+        goto out;
 }
 
 /**
@@ -1242,13 +1270,14 @@ static int pxa_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
         /* make sure it's actually queued on this endpoint */
         list_for_each_entry(req, &ep->queue, queue) {
                 if (&req->req == _req) {
-                        req_done(ep, req, -ECONNRESET);
                         rc = 0;
                         break;
                 }
         }
 
         spin_unlock_irqrestore(&ep->lock, flags);
+        if (!rc)
+                req_done(ep, req, -ECONNRESET, NULL);
         return rc;
 }
 
@@ -1445,7 +1474,6 @@ 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;
@@ -1455,10 +1483,8 @@ static int pxa_ep_disable(struct usb_ep *_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;
@@ -1524,7 +1550,7 @@ static int pxa_udc_get_frame(struct usb_gadget *_gadget)
  * pxa_udc_wakeup - Force udc device out of suspend
  * @_gadget: usb gadget
  *
- * Returns 0 if succesfull, error code otherwise
+ * Returns 0 if successfull, error code otherwise
  */
 static int pxa_udc_wakeup(struct usb_gadget *_gadget)
 {
@@ -1907,8 +1933,10 @@ static void handle_ep0_ctrl_req(struct pxa_udc *udc,
         } u;
         int i;
         int have_extrabytes = 0;
+        unsigned long flags;
 
         nuke(ep, -EPROTO);
+        spin_lock_irqsave(&ep->lock, flags);
 
         /*
          * In the PXA320 manual, in the section about Back-to-Back setup
@@ -1947,10 +1975,13 @@ static void handle_ep0_ctrl_req(struct pxa_udc *udc,
         /* Tell UDC to enter Data Stage */
         ep_write_UDCCSR(ep, UDCCSR0_SA | UDCCSR0_OPC);
 
+        spin_unlock_irqrestore(&ep->lock, flags);
         i = udc->driver->setup(&udc->gadget, &u.r);
+        spin_lock_irqsave(&ep->lock, flags);
         if (i < 0)
                 goto stall;
 out:
+        spin_unlock_irqrestore(&ep->lock, flags);
         return;
 stall:
         ep_dbg(ep, "protocol STALL, udccsr0=%03x err %d\n",
@@ -2055,13 +2086,13 @@ static void handle_ep0(struct pxa_udc *udc, int fifo_irq, int opc_irq)
                 if (req && !ep_is_full(ep))
                         completed = write_ep0_fifo(ep, req);
                 if (completed)
-                        ep0_end_in_req(ep, req);
+                        ep0_end_in_req(ep, req, NULL);
                 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);
+                        ep0_end_out_req(ep, req, NULL);
                 break;
         case STALL:
                 ep_write_UDCCSR(ep, UDCCSR0_FST);
@@ -2091,7 +2122,7 @@ static void handle_ep0(struct pxa_udc *udc, int fifo_irq, int opc_irq)
  * 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.
+ * Is always called when in_interrupt() and with ep->lock released.
  */
 static void handle_ep(struct pxa_ep *ep)
 {
@@ -2100,10 +2131,17 @@ static void handle_ep(struct pxa_ep *ep)
         u32 udccsr;
         int is_in = ep->dir_in;
         int loop = 0;
+        unsigned long           flags;
+
+        spin_lock_irqsave(&ep->lock, flags);
+        if (ep->in_handle_ep)
+                goto recursion_detected;
+        ep->in_handle_ep = 1;
 
         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);
@@ -2122,15 +2160,22 @@ static void handle_ep(struct pxa_ep *ep)
                 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);
+                }
+
+                if (completed) {
+                        if (is_in)
+                                ep_end_in_req(ep, req, &flags);
+                        else
+                                ep_end_out_req(ep, req, &flags);
                 }
         } while (completed);
+
+        ep->in_handle_ep = 0;
+recursion_detected:
+        spin_unlock_irqrestore(&ep->lock, flags);
 }
 
 /**
@@ -2218,9 +2263,13 @@ static void irq_handle_data(int irq, struct pxa_udc *udc)
                         continue;
 
                 udc_writel(udc, UDCISR0, UDCISR_INT(i, UDCISR_INT_MASK));
-                ep = &udc->pxa_ep[i];
-                ep->stats.irqs++;
-                handle_ep(ep);
+
+                WARN_ON(i >= ARRAY_SIZE(udc->pxa_ep));
+                if (i < ARRAY_SIZE(udc->pxa_ep)) {
+                        ep = &udc->pxa_ep[i];
+                        ep->stats.irqs++;
+                        handle_ep(ep);
+                }
         }
 
         for (i = 16; udcisr1 != 0 && i < 24; udcisr1 >>= 2, i++) {
@@ -2228,9 +2277,12 @@ static void irq_handle_data(int irq, struct pxa_udc *udc)
                 if (!(udcisr1 & UDCISR_INT_MASK))
                         continue;
 
-                ep = &udc->pxa_ep[i];
-                ep->stats.irqs++;
-                handle_ep(ep);
+                WARN_ON(i >= ARRAY_SIZE(udc->pxa_ep));
+                if (i < ARRAY_SIZE(udc->pxa_ep)) {
+                        ep = &udc->pxa_ep[i];
+                        ep->stats.irqs++;
+                        handle_ep(ep);
+                }
         }
 
 }
@@ -2439,7 +2491,7 @@ static int __init pxa_udc_probe(struct platform_device *pdev)
         }
 
         retval = -ENOMEM;
-        udc->regs = ioremap(regs->start, regs->end - regs->start + 1);
+        udc->regs = ioremap(regs->start, resource_size(regs));
         if (!udc->regs) {
                 dev_err(&pdev->dev, "Unable to map UDC I/O memory\n");
                 goto err_map;
diff --git a/drivers/usb/gadget/pxa27x_udc.h b/drivers/usb/gadget/pxa27x_udc.h
index e25225e26586..ff61e4866e8a 100644
--- a/drivers/usb/gadget/pxa27x_udc.h
+++ b/drivers/usb/gadget/pxa27x_udc.h
@@ -318,6 +318,11 @@ struct udc_usb_ep {
  * @queue: requests queue
  * @lock: lock to pxa_ep data (queues and stats)
  * @enabled: true when endpoint enabled (not stopped by gadget layer)
+ * @in_handle_ep: number of recursions of handle_ep() function
+ *      Prevents deadlocks or infinite recursions of types :
+ *        irq->handle_ep()->req_done()->req.complete()->pxa_ep_queue()->handle_ep()
+ *      or
+ *        pxa_ep_queue()->handle_ep()->req_done()->req.complete()->pxa_ep_queue()
  * @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
@@ -346,6 +351,7 @@ struct pxa_ep {
         spinlock_t              lock;           /* Protects this structure */
                                                 /* (queues, stats) */
         unsigned                enabled:1;
+        unsigned                in_handle_ep:1;
 
         unsigned                idx:5;
         char                    *name;
diff --git a/drivers/usb/gadget/r8a66597-udc.c b/drivers/usb/gadget/r8a66597-udc.c
index e220fb8091a3..888d8f166c0b 100644
--- a/drivers/usb/gadget/r8a66597-udc.c
+++ b/drivers/usb/gadget/r8a66597-udc.c
@@ -26,6 +26,8 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/slab.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index 48267bc0b2e0..5c0d06c79a81 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -28,6 +28,7 @@
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/proc_fs.h>
+#include <linux/slab.h>
 #include <linux/seq_file.h>
 #include <linux/netdevice.h>
 
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c
index 4b5dbd0127f5..1f73b485732d 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/gadget/s3c-hsotg.c
@@ -22,6 +22,7 @@
 #include <linux/seq_file.h>
 #include <linux/delay.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
@@ -30,7 +31,7 @@
 
 #include <plat/regs-usb-hsotg-phy.h>
 #include <plat/regs-usb-hsotg.h>
-#include <plat/regs-sys.h>
+#include <mach/regs-sys.h>
 #include <plat/udc-hs.h>
 
 #define DMA_ADDR_INVALID (~((dma_addr_t)0))
@@ -317,7 +318,8 @@ static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg)
  *
  * Allocate a new USB request structure appropriate for the specified endpoint
  */
-struct usb_request *s3c_hsotg_ep_alloc_request(struct usb_ep *ep, gfp_t flags)
+static struct usb_request *s3c_hsotg_ep_alloc_request(struct usb_ep *ep,
+                                                      gfp_t flags)
 {
         struct s3c_hsotg_req *req;
 
@@ -373,7 +375,7 @@ static void s3c_hsotg_unmap_dma(struct s3c_hsotg *hsotg,
                 req->dma = DMA_ADDR_INVALID;
                 hs_req->mapped = 0;
         } else {
-                dma_sync_single(hsotg->dev, req->dma, req->length, dir);
+                dma_sync_single_for_cpu(hsotg->dev, req->dma, req->length, dir);
         }
 }
 
@@ -755,7 +757,7 @@ static int s3c_hsotg_map_dma(struct s3c_hsotg *hsotg,
                 hs_req->mapped = 1;
                 req->dma = dma;
         } else {
-                dma_sync_single(hsotg->dev, req->dma, req->length, dir);
+                dma_sync_single_for_cpu(hsotg->dev, req->dma, req->length, dir);
                 hs_req->mapped = 0;
         }
 
@@ -1460,7 +1462,7 @@ static u32 s3c_hsotg_read_frameno(struct s3c_hsotg *hsotg)
  * as the actual data should be sent to the memory directly and we turn
  * on the completion interrupts to get notifications of transfer completion.
  */
-void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg)
+static void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg)
 {
         u32 grxstsr = readl(hsotg->regs + S3C_GRXSTSP);
         u32 epnum, status, size;
@@ -2143,6 +2145,7 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
         u32 epctrl;
         u32 mps;
         int dir_in;
+        int ret = 0;
 
         dev_dbg(hsotg->dev,
                 "%s: ep %s: a 0x%02x, attr 0x%02x, mps 0x%04x, intr %d\n",
@@ -2194,7 +2197,8 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
         switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
         case USB_ENDPOINT_XFER_ISOC:
                 dev_err(hsotg->dev, "no current ISOC support\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
 
         case USB_ENDPOINT_XFER_BULK:
                 epctrl |= S3C_DxEPCTL_EPType_Bulk;
@@ -2233,8 +2237,9 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
         /* enable the endpoint interrupt */
         s3c_hsotg_ctrl_epint(hsotg, index, dir_in, 1);
 
+out:
         spin_unlock_irqrestore(&hs_ep->lock, flags);
-        return 0;
+        return ret;
 }
 
 static int s3c_hsotg_ep_disable(struct usb_ep *ep)
@@ -2582,6 +2587,7 @@ err:
         hsotg->gadget.dev.driver = NULL;
         return ret;
 }
+EXPORT_SYMBOL(usb_gadget_register_driver);
 
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
@@ -3093,7 +3099,7 @@ static void s3c_hsotg_gate(struct platform_device *pdev, bool on)
         local_irq_restore(flags);
 }
 
-struct s3c_hsotg_plat s3c_hsotg_default_pdata;
+static struct s3c_hsotg_plat s3c_hsotg_default_pdata;
 
 static int __devinit s3c_hsotg_probe(struct platform_device *pdev)
 {
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
new file mode 100644
index 000000000000..868d8ee86756
--- /dev/null
+++ b/drivers/usb/gadget/storage_common.c
@@ -0,0 +1,778 @@
+/*
+ * storage_common.c -- Common definitions for mass storage functionality
+ *
+ * Copyright (C) 2003-2008 Alan Stern
+ * Copyeight (C) 2009 Samsung Electronics
+ * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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
+ */
+
+
+/*
+ * This file requires the following identifiers used in USB strings to
+ * be defined (each of type pointer to char):
+ *  - fsg_string_manufacturer -- name of the manufacturer
+ *  - fsg_string_product      -- name of the product
+ *  - fsg_string_serial       -- product's serial
+ *  - fsg_string_config       -- name of the configuration
+ *  - fsg_string_interface    -- name of the interface
+ * The first four are only needed when FSG_DESCRIPTORS_DEVICE_STRINGS
+ * macro is defined prior to including this file.
+ */
+
+/*
+ * When FSG_NO_INTR_EP is defined fsg_fs_intr_in_desc and
+ * fsg_hs_intr_in_desc objects as well as
+ * FSG_FS_FUNCTION_PRE_EP_ENTRIES and FSG_HS_FUNCTION_PRE_EP_ENTRIES
+ * macros are not defined.
+ *
+ * When FSG_NO_DEVICE_STRINGS is defined FSG_STRING_MANUFACTURER,
+ * FSG_STRING_PRODUCT, FSG_STRING_SERIAL and FSG_STRING_CONFIG are not
+ * defined (as well as corresponding entries in string tables are
+ * missing) and FSG_STRING_INTERFACE has value of zero.
+ *
+ * When FSG_NO_OTG is defined fsg_otg_desc won't be defined.
+ */
+
+/*
+ * When FSG_BUFFHD_STATIC_BUFFER is defined when this file is included
+ * the fsg_buffhd structure's buf field will be an array of FSG_BUFLEN
+ * characters rather then a pointer to void.
+ */
+
+
+#include <asm/unaligned.h>
+
+
+/* Thanks to NetChip Technologies for donating this product ID.
+ *
+ * DO NOT REUSE THESE IDs with any other driver!!  Ever!!
+ * Instead:  allocate your own, using normal USB-IF procedures. */
+#define FSG_VENDOR_ID   0x0525  /* NetChip */
+#define FSG_PRODUCT_ID  0xa4a5  /* Linux-USB File-backed Storage Gadget */
+
+
+/*-------------------------------------------------------------------------*/
+
+
+#ifndef DEBUG
+#undef VERBOSE_DEBUG
+#undef DUMP_MSGS
+#endif /* !DEBUG */
+
+#ifdef VERBOSE_DEBUG
+#define VLDBG   LDBG
+#else
+#define VLDBG(lun, fmt, args...) do { } while (0)
+#endif /* VERBOSE_DEBUG */
+
+#define LDBG(lun, fmt, args...)   dev_dbg (&(lun)->dev, fmt, ## args)
+#define LERROR(lun, fmt, args...) dev_err (&(lun)->dev, fmt, ## args)
+#define LWARN(lun, fmt, args...)  dev_warn(&(lun)->dev, fmt, ## args)
+#define LINFO(lun, fmt, args...)  dev_info(&(lun)->dev, fmt, ## args)
+
+/* Keep those macros in sync with thos in
+ * include/linux/ubs/composite.h or else GCC will complain.  If they
+ * are identical (the same names of arguments, white spaces in the
+ * same places) GCC will allow redefinition otherwise (even if some
+ * white space is removed or added) warning will be issued.  No
+ * checking if those symbols is defined is performed because warning
+ * is desired when those macros were defined by someone else to mean
+ * something else. */
+#define DBG(d, fmt, args...)     dev_dbg(&(d)->gadget->dev , fmt , ## args)
+#define VDBG(d, fmt, args...)    dev_vdbg(&(d)->gadget->dev , fmt , ## args)
+#define ERROR(d, fmt, args...)   dev_err(&(d)->gadget->dev , fmt , ## args)
+#define WARNING(d, fmt, args...) dev_warn(&(d)->gadget->dev , fmt , ## args)
+#define INFO(d, fmt, args...)    dev_info(&(d)->gadget->dev , fmt , ## args)
+
+
+
+#ifdef DUMP_MSGS
+
+#  define dump_msg(fsg, /* const char * */ label,                       \
+                   /* const u8 * */ buf, /* unsigned */ length) do {    \
+        if (length < 512) {                                             \
+                DBG(fsg, "%s, length %u:\n", label, length);            \
+                print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,      \
+                               16, 1, buf, length, 0);                  \
+        }                                                               \
+} while (0)
+
+#  define dump_cdb(fsg) do { } while (0)
+
+#else
+
+#  define dump_msg(fsg, /* const char * */ label, \
+                   /* const u8 * */ buf, /* unsigned */ length) do { } while (0)
+
+#  ifdef VERBOSE_DEBUG
+
+#    define dump_cdb(fsg)                                               \
+        print_hex_dump(KERN_DEBUG, "SCSI CDB: ", DUMP_PREFIX_NONE,      \
+                       16, 1, (fsg)->cmnd, (fsg)->cmnd_size, 0)         \
+
+#  else
+
+#    define dump_cdb(fsg) do { } while (0)
+
+#  endif /* VERBOSE_DEBUG */
+
+#endif /* DUMP_MSGS */
+
+
+
+
+
+/*-------------------------------------------------------------------------*/
+
+/* SCSI device types */
+#define TYPE_DISK       0x00
+#define TYPE_CDROM      0x05
+
+/* USB protocol value = the transport method */
+#define USB_PR_CBI      0x00            /* Control/Bulk/Interrupt */
+#define USB_PR_CB       0x01            /* Control/Bulk w/o interrupt */
+#define USB_PR_BULK     0x50            /* Bulk-only */
+
+/* USB subclass value = the protocol encapsulation */
+#define USB_SC_RBC      0x01            /* Reduced Block Commands (flash) */
+#define USB_SC_8020     0x02            /* SFF-8020i, MMC-2, ATAPI (CD-ROM) */
+#define USB_SC_QIC      0x03            /* QIC-157 (tape) */
+#define USB_SC_UFI      0x04            /* UFI (floppy) */
+#define USB_SC_8070     0x05            /* SFF-8070i (removable) */
+#define USB_SC_SCSI     0x06            /* Transparent SCSI */
+
+/* Bulk-only data structures */
+
+/* Command Block Wrapper */
+struct fsg_bulk_cb_wrap {
+        __le32  Signature;              /* Contains 'USBC' */
+        u32     Tag;                    /* Unique per command id */
+        __le32  DataTransferLength;     /* Size of the data */
+        u8      Flags;                  /* Direction in bit 7 */
+        u8      Lun;                    /* LUN (normally 0) */
+        u8      Length;                 /* Of the CDB, <= MAX_COMMAND_SIZE */
+        u8      CDB[16];                /* Command Data Block */
+};
+
+#define USB_BULK_CB_WRAP_LEN    31
+#define USB_BULK_CB_SIG         0x43425355      /* Spells out USBC */
+#define USB_BULK_IN_FLAG        0x80
+
+/* Command Status Wrapper */
+struct bulk_cs_wrap {
+        __le32  Signature;              /* Should = 'USBS' */
+        u32     Tag;                    /* Same as original command */
+        __le32  Residue;                /* Amount not transferred */
+        u8      Status;                 /* See below */
+};
+
+#define USB_BULK_CS_WRAP_LEN    13
+#define USB_BULK_CS_SIG         0x53425355      /* Spells out 'USBS' */
+#define USB_STATUS_PASS         0
+#define USB_STATUS_FAIL         1
+#define USB_STATUS_PHASE_ERROR  2
+
+/* Bulk-only class specific requests */
+#define USB_BULK_RESET_REQUEST          0xff
+#define USB_BULK_GET_MAX_LUN_REQUEST    0xfe
+
+
+/* CBI Interrupt data structure */
+struct interrupt_data {
+        u8      bType;
+        u8      bValue;
+};
+
+#define CBI_INTERRUPT_DATA_LEN          2
+
+/* CBI Accept Device-Specific Command request */
+#define USB_CBI_ADSC_REQUEST            0x00
+
+
+/* Length of a SCSI Command Data Block */
+#define MAX_COMMAND_SIZE        16
+
+/* SCSI commands that we recognize */
+#define SC_FORMAT_UNIT                  0x04
+#define SC_INQUIRY                      0x12
+#define SC_MODE_SELECT_6                0x15
+#define SC_MODE_SELECT_10               0x55
+#define SC_MODE_SENSE_6                 0x1a
+#define SC_MODE_SENSE_10                0x5a
+#define SC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
+#define SC_READ_6                       0x08
+#define SC_READ_10                      0x28
+#define SC_READ_12                      0xa8
+#define SC_READ_CAPACITY                0x25
+#define SC_READ_FORMAT_CAPACITIES       0x23
+#define SC_READ_HEADER                  0x44
+#define SC_READ_TOC                     0x43
+#define SC_RELEASE                      0x17
+#define SC_REQUEST_SENSE                0x03
+#define SC_RESERVE                      0x16
+#define SC_SEND_DIAGNOSTIC              0x1d
+#define SC_START_STOP_UNIT              0x1b
+#define SC_SYNCHRONIZE_CACHE            0x35
+#define SC_TEST_UNIT_READY              0x00
+#define SC_VERIFY                       0x2f
+#define SC_WRITE_6                      0x0a
+#define SC_WRITE_10                     0x2a
+#define SC_WRITE_12                     0xaa
+
+/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
+#define SS_NO_SENSE                             0
+#define SS_COMMUNICATION_FAILURE                0x040800
+#define SS_INVALID_COMMAND                      0x052000
+#define SS_INVALID_FIELD_IN_CDB                 0x052400
+#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE   0x052100
+#define SS_LOGICAL_UNIT_NOT_SUPPORTED           0x052500
+#define SS_MEDIUM_NOT_PRESENT                   0x023a00
+#define SS_MEDIUM_REMOVAL_PREVENTED             0x055302
+#define SS_NOT_READY_TO_READY_TRANSITION        0x062800
+#define SS_RESET_OCCURRED                       0x062900
+#define SS_SAVING_PARAMETERS_NOT_SUPPORTED      0x053900
+#define SS_UNRECOVERED_READ_ERROR               0x031100
+#define SS_WRITE_ERROR                          0x030c02
+#define SS_WRITE_PROTECTED                      0x072700
+
+#define SK(x)           ((u8) ((x) >> 16))      /* Sense Key byte, etc. */
+#define ASC(x)          ((u8) ((x) >> 8))
+#define ASCQ(x)         ((u8) (x))
+
+
+/*-------------------------------------------------------------------------*/
+
+
+struct fsg_lun {
+        struct file     *filp;
+        loff_t          file_length;
+        loff_t          num_sectors;
+
+        unsigned int    initially_ro:1;
+        unsigned int    ro:1;
+        unsigned int    removable:1;
+        unsigned int    cdrom:1;
+        unsigned int    prevent_medium_removal:1;
+        unsigned int    registered:1;
+        unsigned int    info_valid:1;
+
+        u32             sense_data;
+        u32             sense_data_info;
+        u32             unit_attention_data;
+
+        struct device   dev;
+};
+
+#define fsg_lun_is_open(curlun) ((curlun)->filp != NULL)
+
+static struct fsg_lun *fsg_lun_from_dev(struct device *dev)
+{
+        return container_of(dev, struct fsg_lun, dev);
+}
+
+
+/* Big enough to hold our biggest descriptor */
+#define EP0_BUFSIZE     256
+#define DELAYED_STATUS  (EP0_BUFSIZE + 999)     /* An impossibly large value */
+
+/* Number of buffers we will use.  2 is enough for double-buffering */
+#define FSG_NUM_BUFFERS 2
+
+/* Default size of buffer length. */
+#define FSG_BUFLEN      ((u32)16384)
+
+/* Maximal number of LUNs supported in mass storage function */
+#define FSG_MAX_LUNS    8
+
+enum fsg_buffer_state {
+        BUF_STATE_EMPTY = 0,
+        BUF_STATE_FULL,
+        BUF_STATE_BUSY
+};
+
+struct fsg_buffhd {
+#ifdef FSG_BUFFHD_STATIC_BUFFER
+        char                            buf[FSG_BUFLEN];
+#else
+        void                            *buf;
+#endif
+        enum fsg_buffer_state           state;
+        struct fsg_buffhd               *next;
+
+        /* The NetChip 2280 is faster, and handles some protocol faults
+         * better, if we don't submit any short bulk-out read requests.
+         * So we will record the intended request length here. */
+        unsigned int                    bulk_out_intended_length;
+
+        struct usb_request              *inreq;
+        int                             inreq_busy;
+        struct usb_request              *outreq;
+        int                             outreq_busy;
+};
+
+enum fsg_state {
+        /* This one isn't used anywhere */
+        FSG_STATE_COMMAND_PHASE = -10,
+        FSG_STATE_DATA_PHASE,
+        FSG_STATE_STATUS_PHASE,
+
+        FSG_STATE_IDLE = 0,
+        FSG_STATE_ABORT_BULK_OUT,
+        FSG_STATE_RESET,
+        FSG_STATE_INTERFACE_CHANGE,
+        FSG_STATE_CONFIG_CHANGE,
+        FSG_STATE_DISCONNECT,
+        FSG_STATE_EXIT,
+        FSG_STATE_TERMINATED
+};
+
+enum data_direction {
+        DATA_DIR_UNKNOWN = 0,
+        DATA_DIR_FROM_HOST,
+        DATA_DIR_TO_HOST,
+        DATA_DIR_NONE
+};
+
+
+/*-------------------------------------------------------------------------*/
+
+
+static inline u32 get_unaligned_be24(u8 *buf)
+{
+        return 0xffffff & (u32) get_unaligned_be32(buf - 1);
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+
+enum {
+#ifndef FSG_NO_DEVICE_STRINGS
+        FSG_STRING_MANUFACTURER = 1,
+        FSG_STRING_PRODUCT,
+        FSG_STRING_SERIAL,
+        FSG_STRING_CONFIG,
+#endif
+        FSG_STRING_INTERFACE
+};
+
+
+#ifndef FSG_NO_OTG
+static struct usb_otg_descriptor
+fsg_otg_desc = {
+        .bLength =              sizeof fsg_otg_desc,
+        .bDescriptorType =      USB_DT_OTG,
+
+        .bmAttributes =         USB_OTG_SRP,
+};
+#endif
+
+/* There is only one interface. */
+
+static struct usb_interface_descriptor
+fsg_intf_desc = {
+        .bLength =              sizeof fsg_intf_desc,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bNumEndpoints =        2,              /* Adjusted during fsg_bind() */
+        .bInterfaceClass =      USB_CLASS_MASS_STORAGE,
+        .bInterfaceSubClass =   USB_SC_SCSI,    /* Adjusted during fsg_bind() */
+        .bInterfaceProtocol =   USB_PR_BULK,    /* Adjusted during fsg_bind() */
+        .iInterface =           FSG_STRING_INTERFACE,
+};
+
+/* Three full-speed endpoint descriptors: bulk-in, bulk-out,
+ * and interrupt-in. */
+
+static struct usb_endpoint_descriptor
+fsg_fs_bulk_in_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        /* wMaxPacketSize set by autoconfiguration */
+};
+
+static struct usb_endpoint_descriptor
+fsg_fs_bulk_out_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        /* wMaxPacketSize set by autoconfiguration */
+};
+
+#ifndef FSG_NO_INTR_EP
+
+static struct usb_endpoint_descriptor
+fsg_fs_intr_in_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(2),
+        .bInterval =            32,     /* frames -> 32 ms */
+};
+
+#ifndef FSG_NO_OTG
+#  define FSG_FS_FUNCTION_PRE_EP_ENTRIES        2
+#else
+#  define FSG_FS_FUNCTION_PRE_EP_ENTRIES        1
+#endif
+
+#endif
+
+static struct usb_descriptor_header *fsg_fs_function[] = {
+#ifndef FSG_NO_OTG
+        (struct usb_descriptor_header *) &fsg_otg_desc,
+#endif
+        (struct usb_descriptor_header *) &fsg_intf_desc,
+        (struct usb_descriptor_header *) &fsg_fs_bulk_in_desc,
+        (struct usb_descriptor_header *) &fsg_fs_bulk_out_desc,
+#ifndef FSG_NO_INTR_EP
+        (struct usb_descriptor_header *) &fsg_fs_intr_in_desc,
+#endif
+        NULL,
+};
+
+
+/*
+ * USB 2.0 devices need to expose both high speed and full speed
+ * descriptors, unless they only run at full speed.
+ *
+ * That means alternate endpoint descriptors (bigger packets)
+ * and a "device qualifier" ... plus more construction options
+ * for the config descriptor.
+ */
+static struct usb_endpoint_descriptor
+fsg_hs_bulk_in_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        /* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor
+fsg_hs_bulk_out_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        /* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512),
+        .bInterval =            1,      /* NAK every 1 uframe */
+};
+
+#ifndef FSG_NO_INTR_EP
+
+static struct usb_endpoint_descriptor
+fsg_hs_intr_in_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        /* bEndpointAddress copied from fs_intr_in_desc during fsg_bind() */
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(2),
+        .bInterval =            9,      /* 2**(9-1) = 256 uframes -> 32 ms */
+};
+
+#ifndef FSG_NO_OTG
+#  define FSG_HS_FUNCTION_PRE_EP_ENTRIES        2
+#else
+#  define FSG_HS_FUNCTION_PRE_EP_ENTRIES        1
+#endif
+
+#endif
+
+static struct usb_descriptor_header *fsg_hs_function[] = {
+#ifndef FSG_NO_OTG
+        (struct usb_descriptor_header *) &fsg_otg_desc,
+#endif
+        (struct usb_descriptor_header *) &fsg_intf_desc,
+        (struct usb_descriptor_header *) &fsg_hs_bulk_in_desc,
+        (struct usb_descriptor_header *) &fsg_hs_bulk_out_desc,
+#ifndef FSG_NO_INTR_EP
+        (struct usb_descriptor_header *) &fsg_hs_intr_in_desc,
+#endif
+        NULL,
+};
+
+/* Maxpacket and other transfer characteristics vary by speed. */
+static struct usb_endpoint_descriptor *
+fsg_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *fs,
+                struct usb_endpoint_descriptor *hs)
+{
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return hs;
+        return fs;
+}
+
+
+/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
+static struct usb_string                fsg_strings[] = {
+#ifndef FSG_NO_DEVICE_STRINGS
+        {FSG_STRING_MANUFACTURER,       fsg_string_manufacturer},
+        {FSG_STRING_PRODUCT,            fsg_string_product},
+        {FSG_STRING_SERIAL,             fsg_string_serial},
+        {FSG_STRING_CONFIG,             fsg_string_config},
+#endif
+        {FSG_STRING_INTERFACE,          fsg_string_interface},
+        {}
+};
+
+static struct usb_gadget_strings        fsg_stringtab = {
+        .language       = 0x0409,               /* en-us */
+        .strings        = fsg_strings,
+};
+
+
+ /*-------------------------------------------------------------------------*/
+
+/* If the next two routines are called while the gadget is registered,
+ * the caller must own fsg->filesem for writing. */
+
+static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
+{
+        int                             ro;
+        struct file                     *filp = NULL;
+        int                             rc = -EINVAL;
+        struct inode                    *inode = NULL;
+        loff_t                          size;
+        loff_t                          num_sectors;
+        loff_t                          min_sectors;
+
+        /* R/W if we can, R/O if we must */
+        ro = curlun->initially_ro;
+        if (!ro) {
+                filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
+                if (-EROFS == PTR_ERR(filp))
+                        ro = 1;
+        }
+        if (ro)
+                filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
+        if (IS_ERR(filp)) {
+                LINFO(curlun, "unable to open backing file: %s\n", filename);
+                return PTR_ERR(filp);
+        }
+
+        if (!(filp->f_mode & FMODE_WRITE))
+                ro = 1;
+
+        if (filp->f_path.dentry)
+                inode = filp->f_path.dentry->d_inode;
+        if (inode && S_ISBLK(inode->i_mode)) {
+                if (bdev_read_only(inode->i_bdev))
+                        ro = 1;
+        } else if (!inode || !S_ISREG(inode->i_mode)) {
+                LINFO(curlun, "invalid file type: %s\n", filename);
+                goto out;
+        }
+
+        /* If we can't read the file, it's no good.
+         * If we can't write the file, use it read-only. */
+        if (!filp->f_op || !(filp->f_op->read || filp->f_op->aio_read)) {
+                LINFO(curlun, "file not readable: %s\n", filename);
+                goto out;
+        }
+        if (!(filp->f_op->write || filp->f_op->aio_write))
+                ro = 1;
+
+        size = i_size_read(inode->i_mapping->host);
+        if (size < 0) {
+                LINFO(curlun, "unable to find file size: %s\n", filename);
+                rc = (int) size;
+                goto out;
+        }
+        num_sectors = size >> 9;        /* File size in 512-byte blocks */
+        min_sectors = 1;
+        if (curlun->cdrom) {
+                num_sectors &= ~3;      /* Reduce to a multiple of 2048 */
+                min_sectors = 300*4;    /* Smallest track is 300 frames */
+                if (num_sectors >= 256*60*75*4) {
+                        num_sectors = (256*60*75 - 1) * 4;
+                        LINFO(curlun, "file too big: %s\n", filename);
+                        LINFO(curlun, "using only first %d blocks\n",
+                                        (int) num_sectors);
+                }
+        }
+        if (num_sectors < min_sectors) {
+                LINFO(curlun, "file too small: %s\n", filename);
+                rc = -ETOOSMALL;
+                goto out;
+        }
+
+        get_file(filp);
+        curlun->ro = ro;
+        curlun->filp = filp;
+        curlun->file_length = size;
+        curlun->num_sectors = num_sectors;
+        LDBG(curlun, "open backing file: %s\n", filename);
+        rc = 0;
+
+out:
+        filp_close(filp, current->files);
+        return rc;
+}
+
+
+static void fsg_lun_close(struct fsg_lun *curlun)
+{
+        if (curlun->filp) {
+                LDBG(curlun, "close backing file\n");
+                fput(curlun->filp);
+                curlun->filp = NULL;
+        }
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+/* Sync the file data, don't bother with the metadata.
+ * This code was copied from fs/buffer.c:sys_fdatasync(). */
+static int fsg_lun_fsync_sub(struct fsg_lun *curlun)
+{
+        struct file     *filp = curlun->filp;
+
+        if (curlun->ro || !filp)
+                return 0;
+        return vfs_fsync(filp, filp->f_path.dentry, 1);
+}
+
+static void store_cdrom_address(u8 *dest, int msf, u32 addr)
+{
+        if (msf) {
+                /* Convert to Minutes-Seconds-Frames */
+                addr >>= 2;             /* Convert to 2048-byte frames */
+                addr += 2*75;           /* Lead-in occupies 2 seconds */
+                dest[3] = addr % 75;    /* Frames */
+                addr /= 75;
+                dest[2] = addr % 60;    /* Seconds */
+                addr /= 60;
+                dest[1] = addr;         /* Minutes */
+                dest[0] = 0;            /* Reserved */
+        } else {
+                /* Absolute sector */
+                put_unaligned_be32(addr, dest);
+        }
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+
+static ssize_t fsg_show_ro(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
+
+        return sprintf(buf, "%d\n", fsg_lun_is_open(curlun)
+                                  ? curlun->ro
+                                  : curlun->initially_ro);
+}
+
+static ssize_t fsg_show_file(struct device *dev, struct device_attribute *attr,
+                             char *buf)
+{
+        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
+        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
+        char            *p;
+        ssize_t         rc;
+
+        down_read(filesem);
+        if (fsg_lun_is_open(curlun)) {  /* Get the complete pathname */
+                p = d_path(&curlun->filp->f_path, buf, PAGE_SIZE - 1);
+                if (IS_ERR(p))
+                        rc = PTR_ERR(p);
+                else {
+                        rc = strlen(p);
+                        memmove(buf, p, rc);
+                        buf[rc] = '\n';         /* Add a newline */
+                        buf[++rc] = 0;
+                }
+        } else {                                /* No file, return 0 bytes */
+                *buf = 0;
+                rc = 0;
+        }
+        up_read(filesem);
+        return rc;
+}
+
+
+static ssize_t fsg_store_ro(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+        ssize_t         rc = count;
+        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
+        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
+        int             i;
+
+        if (sscanf(buf, "%d", &i) != 1)
+                return -EINVAL;
+
+        /* Allow the write-enable status to change only while the backing file
+         * is closed. */
+        down_read(filesem);
+        if (fsg_lun_is_open(curlun)) {
+                LDBG(curlun, "read-only status change prevented\n");
+                rc = -EBUSY;
+        } else {
+                curlun->ro = !!i;
+                curlun->initially_ro = !!i;
+                LDBG(curlun, "read-only status set to %d\n", curlun->ro);
+        }
+        up_read(filesem);
+        return rc;
+}
+
+static ssize_t fsg_store_file(struct device *dev, struct device_attribute *attr,
+                              const char *buf, size_t count)
+{
+        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
+        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
+        int             rc = 0;
+
+        if (curlun->prevent_medium_removal && fsg_lun_is_open(curlun)) {
+                LDBG(curlun, "eject attempt prevented\n");
+                return -EBUSY;                          /* "Door is locked" */
+        }
+
+        /* Remove a trailing newline */
+        if (count > 0 && buf[count-1] == '\n')
+                ((char *) buf)[count-1] = 0;            /* Ugh! */
+
+        /* Eject current medium */
+        down_write(filesem);
+        if (fsg_lun_is_open(curlun)) {
+                fsg_lun_close(curlun);
+                curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
+        }
+
+        /* Load new medium */
+        if (count > 0 && buf[0]) {
+                rc = fsg_lun_open(curlun, buf);
+                if (rc == 0)
+                        curlun->unit_attention_data =
+                                        SS_NOT_READY_TO_READY_TRANSITION;
+        }
+        up_write(filesem);
+        return (rc < 0 ? rc : count);
+}
diff --git a/drivers/usb/gadget/u_audio.c b/drivers/usb/gadget/u_audio.c
index 8252595d619d..7a86d2c9109c 100644
--- a/drivers/usb/gadget/u_audio.c
+++ b/drivers/usb/gadget/u_audio.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/delay.h>
 #include <linux/ctype.h>
@@ -288,6 +289,7 @@ static int gaudio_close_snd_dev(struct gaudio *gau)
         return 0;
 }
 
+static struct gaudio *the_card;
 /**
  * gaudio_setup - setup ALSA interface and preparing for USB transfer
  *
@@ -303,6 +305,9 @@ int __init gaudio_setup(struct gaudio *card)
         if (ret)
                 ERROR(card, "we need at least one control device\n");
 
+        if (!the_card)
+                the_card = card;
+
         return ret;
 
 }
@@ -312,9 +317,11 @@ int __init gaudio_setup(struct gaudio *card)
  *
  * This is called to free all resources allocated by @gaudio_setup().
  */
-void gaudio_cleanup(struct gaudio *card)
+void gaudio_cleanup(void)
 {
-        if (card)
-                gaudio_close_snd_dev(card);
+        if (the_card) {
+                gaudio_close_snd_dev(the_card);
+                the_card = NULL;
+        }
 }
 
diff --git a/drivers/usb/gadget/u_audio.h b/drivers/usb/gadget/u_audio.h
index cc8d159c648a..08ffce3298e6 100644
--- a/drivers/usb/gadget/u_audio.h
+++ b/drivers/usb/gadget/u_audio.h
@@ -51,6 +51,6 @@ struct gaudio {
 };
 
 int gaudio_setup(struct gaudio *card);
-void gaudio_cleanup(struct gaudio *card);
+void gaudio_cleanup(void);
 
 #endif /* __U_AUDIO_H */
diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
index 2fc02bd95848..07f4178ad178 100644
--- a/drivers/usb/gadget/u_ether.c
+++ b/drivers/usb/gadget/u_ether.c
@@ -23,6 +23,7 @@
 /* #define VERBOSE_DEBUG */
 
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/device.h>
 #include <linux/ctype.h>
 #include <linux/etherdevice.h>
@@ -746,6 +747,10 @@ static const struct net_device_ops eth_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
+static struct device_type gadget_type = {
+        .name   = "gadget",
+};
+
 /**
  * gether_setup - initialize one ethernet-over-usb link
  * @g: gadget to associated with these links
@@ -808,6 +813,7 @@ int __init gether_setup(struct usb_gadget *g, u8 ethaddr[ETH_ALEN])
 
         dev->gadget = g;
         SET_NETDEV_DEV(net, &g->dev);
+        SET_NETDEV_DEVTYPE(net, &gadget_type);
 
         status = register_netdev(net);
         if (status < 0) {
diff --git a/drivers/usb/gadget/u_ether.h b/drivers/usb/gadget/u_ether.h
index 91b39ffdf6ea..3c8c0c9f9d72 100644
--- a/drivers/usb/gadget/u_ether.h
+++ b/drivers/usb/gadget/u_ether.h
@@ -93,13 +93,6 @@ static inline bool can_support_ecm(struct usb_gadget *gadget)
         if (!gadget_supports_altsettings(gadget))
                 return false;
 
-        /* SA1100 can do ECM, *without* status endpoint ... but we'll
-         * only use it in non-ECM mode for backwards compatibility
-         * (and since we currently require a status endpoint)
-         */
-        if (gadget_is_sa1100(gadget))
-                return false;
-
         /* Everything else is *presumably* fine ... but this is a bit
          * chancy, so be **CERTAIN** there are no hardware issues with
          * your controller.  Add it above if it can't handle CDC.
@@ -112,7 +105,7 @@ int geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 int ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 int eem_bind_config(struct usb_configuration *c);
 
-#ifdef CONFIG_USB_ETH_RNDIS
+#ifdef USB_ETH_RNDIS
 
 int rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
index adf8260c3a6a..16bdf77f582a 100644
--- a/drivers/usb/gadget/u_serial.c
+++ b/drivers/usb/gadget/u_serial.c
@@ -23,6 +23,7 @@
 #include <linux/delay.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
+#include <linux/slab.h>
 
 #include "u_serial.h"
 
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index 2d772401b7ad..807280d069f9 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -50,6 +50,7 @@
 /* #define VERBOSE_DEBUG */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/utsname.h>
 #include <linux/device.h>
 
@@ -297,12 +298,10 @@ static int __init zero_bind(struct usb_composite_dev *cdev)
          */
         if (loopdefault) {
                 loopback_add(cdev, autoresume != 0);
-                if (!gadget_is_sh(gadget))
-                        sourcesink_add(cdev, autoresume != 0);
+                sourcesink_add(cdev, autoresume != 0);
         } else {
                 sourcesink_add(cdev, autoresume != 0);
-                if (!gadget_is_sh(gadget))
-                        loopback_add(cdev, autoresume != 0);
+                loopback_add(cdev, autoresume != 0);
         }
 
         gcnum = usb_gadget_controller_number(gadget);
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 9b43b226817f..8d3df0397de3 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -90,14 +90,25 @@ config USB_EHCI_TT_NEWSCHED
 
 config USB_EHCI_BIG_ENDIAN_MMIO
         bool
-        depends on USB_EHCI_HCD && (PPC_CELLEB || PPC_PS3 || 440EPX || ARCH_IXP4XX)
+        depends on USB_EHCI_HCD && (PPC_CELLEB || PPC_PS3 || 440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX)
         default y
 
 config USB_EHCI_BIG_ENDIAN_DESC
         bool
-        depends on USB_EHCI_HCD && (440EPX || ARCH_IXP4XX)
+        depends on USB_EHCI_HCD && (440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX)
         default y
 
+config XPS_USB_HCD_XILINX
+        bool "Use Xilinx usb host EHCI controller core"
+        depends on USB_EHCI_HCD && (PPC32 || MICROBLAZE)
+        select USB_EHCI_BIG_ENDIAN_DESC
+        select USB_EHCI_BIG_ENDIAN_MMIO
+        ---help---
+                Xilinx xps USB host controller core is EHCI compilant and has
+                transaction translator built-in. It can be configured to either
+                support both high speed and full speed devices, or high speed
+                devices only.
+
 config USB_EHCI_FSL
         bool "Support for Freescale on-chip EHCI USB controller"
         depends on USB_EHCI_HCD && FSL_SOC
@@ -105,6 +116,13 @@ config USB_EHCI_FSL
         ---help---
           Variation of ARC USB block used in some Freescale chips.
 
+config USB_EHCI_MXC
+        bool "Support for Freescale on-chip EHCI USB controller"
+        depends on USB_EHCI_HCD && ARCH_MXC
+        select USB_EHCI_ROOT_HUB_TT
+        ---help---
+          Variation of ARC USB block used in some Freescale chips.
+
 config USB_EHCI_HCD_PPC_OF
         bool "EHCI support for PPC USB controller on OF platform bus"
         depends on USB_EHCI_HCD && PPC_OF
@@ -381,3 +399,14 @@ config USB_HWA_HCD
 
           To compile this driver a module, choose M here: the module
           will be called "hwa-hc".
+
+config USB_IMX21_HCD
+       tristate "iMX21 HCD support"
+       depends on USB && ARM && MACH_MX21
+       help
+         This driver enables support for the on-chip USB host in the
+         iMX21 processor.
+
+         To compile this driver as a module, choose M here: the
+         module will be called "imx21-hcd".
+
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index f58b2494c44a..b6315aa47f7a 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -12,7 +12,7 @@ fhci-objs := fhci-hcd.o fhci-hub.o fhci-q.o fhci-mem.o \
 ifeq ($(CONFIG_FHCI_DEBUG),y)
 fhci-objs += fhci-dbg.o
 endif
-xhci-objs := xhci-hcd.o xhci-mem.o xhci-pci.o xhci-ring.o xhci-hub.o xhci-dbg.o
+xhci-hcd-objs := xhci.o xhci-mem.o xhci-pci.o xhci-ring.o xhci-hub.o xhci-dbg.o
 
 obj-$(CONFIG_USB_WHCI_HCD)      += whci/
 
@@ -25,10 +25,12 @@ obj-$(CONFIG_USB_ISP1362_HCD)	+= isp1362-hcd.o
 obj-$(CONFIG_USB_OHCI_HCD)      += ohci-hcd.o
 obj-$(CONFIG_USB_UHCI_HCD)      += uhci-hcd.o
 obj-$(CONFIG_USB_FHCI_HCD)      += fhci.o
-obj-$(CONFIG_USB_XHCI_HCD)      += xhci.o
+obj-$(CONFIG_USB_XHCI_HCD)      += xhci-hcd.o
 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
 obj-$(CONFIG_USB_HWA_HCD)       += hwa-hc.o
+obj-$(CONFIG_USB_IMX21_HCD)     += imx21-hcd.o
+
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index 87c1b7c34c0e..51bd0edf544f 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -149,7 +149,7 @@ static int __init ehci_atmel_drv_probe(struct platform_device *pdev)
                 goto fail_request_resource;
         }
         hcd->rsrc_start = res->start;
-        hcd->rsrc_len = res->end - res->start + 1;
+        hcd->rsrc_len = resource_size(res);
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
                                 driver->description)) {
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index ed77be76d6bb..e3a74e75e822 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -121,6 +121,7 @@ static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
+        struct resource *res;
         int ret;
 
         if (usb_disabled())
@@ -144,8 +145,9 @@ static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
         if (!hcd)
                 return -ENOMEM;
 
-        hcd->rsrc_start = pdev->resource[0].start;
-        hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                 pr_debug("request_mem_region failed");
@@ -297,7 +299,7 @@ static int ehci_hcd_au1xxx_drv_resume(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops au1xxx_ehci_pmops = {
+static const struct dev_pm_ops au1xxx_ehci_pmops = {
         .suspend        = ehci_hcd_au1xxx_drv_suspend,
         .resume         = ehci_hcd_au1xxx_drv_resume,
 };
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 991174937db3..0e26aa13f158 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2005 MontaVista Software
+ * Copyright 2005-2009 MontaVista Software, Inc.
+ * Copyright 2008      Freescale Semiconductor, Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -17,17 +18,20 @@
  *
  * Ported to 834x by Randy Vinson <rvinson@mvista.com> using code provided
  * by Hunter Wu.
+ * Power Management support by Dave Liu <daveliu@freescale.com>,
+ * Jerry Huang <Chang-Ming.Huang@freescale.com> and
+ * Anton Vorontsov <avorontsov@ru.mvista.com>.
  */
 
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
 #include <linux/platform_device.h>
 #include <linux/fsl_devices.h>
 
 #include "ehci-fsl.h"
 
-/* FIXME: Power Management is un-ported so temporarily disable it */
-#undef CONFIG_PM
-
-
 /* configure so an HC device and id are always provided */
 /* always called with process context; sleeping is OK */
 
@@ -40,8 +44,8 @@
  * Allocates basic resources for this USB host controller.
  *
  */
-int usb_hcd_fsl_probe(const struct hc_driver *driver,
-                      struct platform_device *pdev)
+static int usb_hcd_fsl_probe(const struct hc_driver *driver,
+                             struct platform_device *pdev)
 {
         struct fsl_usb2_platform_data *pdata;
         struct usb_hcd *hcd;
@@ -147,7 +151,8 @@ int usb_hcd_fsl_probe(const struct hc_driver *driver,
  * Reverses the effect of usb_hcd_fsl_probe().
  *
  */
-void usb_hcd_fsl_remove(struct usb_hcd *hcd, struct platform_device *pdev)
+static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
+                               struct platform_device *pdev)
 {
         usb_remove_hcd(hcd);
         iounmap(hcd->regs);
@@ -284,10 +289,81 @@ static int ehci_fsl_setup(struct usb_hcd *hcd)
         return retval;
 }
 
+struct ehci_fsl {
+        struct ehci_hcd ehci;
+
+#ifdef CONFIG_PM
+        /* Saved USB PHY settings, need to restore after deep sleep. */
+        u32 usb_ctrl;
+#endif
+};
+
+#ifdef CONFIG_PM
+
+static struct ehci_fsl *hcd_to_ehci_fsl(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        return container_of(ehci, struct ehci_fsl, ehci);
+}
+
+static int ehci_fsl_drv_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_fsl *ehci_fsl = hcd_to_ehci_fsl(hcd);
+        void __iomem *non_ehci = hcd->regs;
+
+        if (!fsl_deep_sleep())
+                return 0;
+
+        ehci_fsl->usb_ctrl = in_be32(non_ehci + FSL_SOC_USB_CTRL);
+        return 0;
+}
+
+static int ehci_fsl_drv_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_fsl *ehci_fsl = hcd_to_ehci_fsl(hcd);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        void __iomem *non_ehci = hcd->regs;
+
+        if (!fsl_deep_sleep())
+                return 0;
+
+        usb_root_hub_lost_power(hcd->self.root_hub);
+
+        /* Restore USB PHY settings and enable the controller. */
+        out_be32(non_ehci + FSL_SOC_USB_CTRL, ehci_fsl->usb_ctrl);
+
+        ehci_reset(ehci);
+        ehci_fsl_reinit(ehci);
+
+        return 0;
+}
+
+static int ehci_fsl_drv_restore(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+
+        usb_root_hub_lost_power(hcd->self.root_hub);
+        return 0;
+}
+
+static struct dev_pm_ops ehci_fsl_pm_ops = {
+        .suspend = ehci_fsl_drv_suspend,
+        .resume = ehci_fsl_drv_resume,
+        .restore = ehci_fsl_drv_restore,
+};
+
+#define EHCI_FSL_PM_OPS         (&ehci_fsl_pm_ops)
+#else
+#define EHCI_FSL_PM_OPS         NULL
+#endif /* CONFIG_PM */
+
 static const struct hc_driver ehci_fsl_hc_driver = {
         .description = hcd_name,
         .product_desc = "Freescale On-Chip EHCI Host Controller",
-        .hcd_priv_size = sizeof(struct ehci_hcd),
+        .hcd_priv_size = sizeof(struct ehci_fsl),
 
         /*
          * generic hardware linkage
@@ -354,6 +430,7 @@ static struct platform_driver ehci_fsl_driver = {
         .remove = ehci_fsl_drv_remove,
         .shutdown = usb_hcd_platform_shutdown,
         .driver = {
-                   .name = "fsl-ehci",
+                .name = "fsl-ehci",
+                .pm = EHCI_FSL_PM_OPS,
         },
 };
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index f5f5601701c9..13ead00aecd5 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -23,7 +23,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/sched.h>
-#include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/errno.h>
 #include <linux/init.h>
@@ -35,6 +34,7 @@
 #include <linux/moduleparam.h>
 #include <linux/dma-mapping.h>
 #include <linux/debugfs.h>
+#include <linux/slab.h>
 
 #include "../core/hcd.h"
 
@@ -210,7 +210,7 @@ static int handshake_on_error_set_halt(struct ehci_hcd *ehci, void __iomem *ptr,
         if (error) {
                 ehci_halt(ehci);
                 ehci_to_hcd(ehci)->state = HC_STATE_HALT;
-                ehci_err(ehci, "force halt; handhake %p %08x %08x -> %d\n",
+                ehci_err(ehci, "force halt; handshake %p %08x %08x -> %d\n",
                         ptr, mask, done, error);
         }
 
@@ -543,13 +543,14 @@ static int ehci_init(struct usb_hcd *hcd)
          */
         ehci->periodic_size = DEFAULT_I_TDPS;
         INIT_LIST_HEAD(&ehci->cached_itd_list);
+        INIT_LIST_HEAD(&ehci->cached_sitd_list);
         if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
                 return retval;
 
         /* controllers may cache some of the periodic schedule ... */
         hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
         if (HCC_ISOC_CACHE(hcc_params))         // full frame cache
-                ehci->i_thresh = 8;
+                ehci->i_thresh = 2 + 8;
         else                                    // N microframes cached
                 ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
 
@@ -605,6 +606,8 @@ static int ehci_init(struct usb_hcd *hcd)
         }
         ehci->command = temp;
 
+        /* Accept arbitrarily long scatter-gather lists */
+        hcd->self.sg_tablesize = ~0;
         return 0;
 }
 
@@ -785,9 +788,10 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
 
                         /* start 20 msec resume signaling from this port,
                          * and make khubd collect PORT_STAT_C_SUSPEND to
-                         * stop that signaling.
+                         * stop that signaling.  Use 5 ms extra for safety,
+                         * like usb_port_resume() does.
                          */
-                        ehci->reset_done [i] = jiffies + msecs_to_jiffies (20);
+                        ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
                         ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
                         mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
                 }
@@ -992,7 +996,7 @@ rescan:
         /* endpoints can be iso streams.  for now, we don't
          * accelerate iso completions ... so spin a while.
          */
-        if (qh->hw->hw_info1 == 0) {
+        if (qh->hw == NULL) {
                 ehci_vdbg (ehci, "iso delay\n");
                 goto idle_timeout;
         }
@@ -1105,11 +1109,21 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ehci_fsl_driver
 #endif
 
+#ifdef CONFIG_USB_EHCI_MXC
+#include "ehci-mxc.c"
+#define PLATFORM_DRIVER         ehci_mxc_driver
+#endif
+
 #ifdef CONFIG_SOC_AU1200
 #include "ehci-au1xxx.c"
 #define PLATFORM_DRIVER         ehci_hcd_au1xxx_driver
 #endif
 
+#ifdef CONFIG_ARCH_OMAP3
+#include "ehci-omap.c"
+#define        PLATFORM_DRIVER         ehci_hcd_omap_driver
+#endif
+
 #ifdef CONFIG_PPC_PS3
 #include "ehci-ps3.c"
 #define PS3_SYSTEM_BUS_DRIVER   ps3_ehci_driver
@@ -1120,6 +1134,11 @@ MODULE_LICENSE ("GPL");
 #define OF_PLATFORM_DRIVER      ehci_hcd_ppc_of_driver
 #endif
 
+#ifdef CONFIG_XPS_USB_HCD_XILINX
+#include "ehci-xilinx-of.c"
+#define OF_PLATFORM_DRIVER      ehci_hcd_xilinx_of_driver
+#endif
+
 #ifdef CONFIG_PLAT_ORION
 #include "ehci-orion.c"
 #define PLATFORM_DRIVER         ehci_orion_driver
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 1b6f1c0e5cee..c7178bcde67a 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -120,9 +120,26 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
         del_timer_sync(&ehci->watchdog);
         del_timer_sync(&ehci->iaa_watchdog);
 
-        port = HCS_N_PORTS (ehci->hcs_params);
         spin_lock_irq (&ehci->lock);
 
+        /* Once the controller is stopped, port resumes that are already
+         * in progress won't complete.  Hence if remote wakeup is enabled
+         * for the root hub and any ports are in the middle of a resume or
+         * remote wakeup, we must fail the suspend.
+         */
+        if (hcd->self.root_hub->do_remote_wakeup) {
+                port = HCS_N_PORTS(ehci->hcs_params);
+                while (port--) {
+                        if (ehci->reset_done[port] != 0) {
+                                spin_unlock_irq(&ehci->lock);
+                                ehci_dbg(ehci, "suspend failed because "
+                                                "port %d is resuming\n",
+                                                port + 1);
+                                return -EBUSY;
+                        }
+                }
+        }
+
         /* stop schedules, clean any completed work */
         if (HC_IS_RUNNING(hcd->state)) {
                 ehci_quiesce (ehci);
@@ -138,6 +155,7 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
          */
         ehci->bus_suspended = 0;
         ehci->owned_ports = 0;
+        port = HCS_N_PORTS(ehci->hcs_params);
         while (port--) {
                 u32 __iomem     *reg = &ehci->regs->port_status [port];
                 u32             t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
@@ -178,7 +196,9 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
                         if (hostpc_reg) {
                                 u32     t3;
 
+                                spin_unlock_irq(&ehci->lock);
                                 msleep(5);/* 5ms for HCD enter low pwr mode */
+                                spin_lock_irq(&ehci->lock);
                                 t3 = ehci_readl(ehci, hostpc_reg);
                                 ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg);
                                 t3 = ehci_readl(ehci, hostpc_reg);
@@ -236,7 +256,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         }
 
         if (unlikely(ehci->debug)) {
-                if (ehci->debug && !dbgp_reset_prep())
+                if (!dbgp_reset_prep())
                         ehci->debug = NULL;
                 else
                         dbgp_external_startup();
@@ -781,7 +801,7 @@ static int ehci_hub_control (
                          * this bit; seems too long to spin routinely...
                          */
                         retval = handshake(ehci, status_reg,
-                                        PORT_RESET, 0, 750);
+                                        PORT_RESET, 0, 1000);
                         if (retval != 0) {
                                 ehci_err (ehci, "port %d reset error %d\n",
                                         wIndex + 1, retval);
@@ -886,17 +906,18 @@ static int ehci_hub_control (
                         if ((temp & PORT_PE) == 0
                                         || (temp & PORT_RESET) != 0)
                                 goto error;
-                        ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
+
                         /* After above check the port must be connected.
                          * Set appropriate bit thus could put phy into low power
                          * mode if we have hostpc feature
                          */
+                        temp &= ~PORT_WKCONN_E;
+                        temp |= PORT_WKDISC_E | PORT_WKOC_E;
+                        ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
                         if (hostpc_reg) {
-                                temp &= ~PORT_WKCONN_E;
-                                temp |= (PORT_WKDISC_E | PORT_WKOC_E);
-                                ehci_writel(ehci, temp | PORT_SUSPEND,
-                                                        status_reg);
+                                spin_unlock_irqrestore(&ehci->lock, flags);
                                 msleep(5);/* 5ms for HCD enter low pwr mode */
+                                spin_lock_irqsave(&ehci->lock, flags);
                                 temp1 = ehci_readl(ehci, hostpc_reg);
                                 ehci_writel(ehci, temp1 | HOSTPC_PHCD,
                                         hostpc_reg);
diff --git a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c
index aeda96e0af67..1f3f01eacaf0 100644
--- a/drivers/usb/host/ehci-mem.c
+++ b/drivers/usb/host/ehci-mem.c
@@ -136,7 +136,7 @@ static inline void qh_put (struct ehci_qh *qh)
 
 static void ehci_mem_cleanup (struct ehci_hcd *ehci)
 {
-        free_cached_itd_list(ehci);
+        free_cached_lists(ehci);
         if (ehci->async)
                 qh_put (ehci->async);
         ehci->async = NULL;
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
new file mode 100644
index 000000000000..ead59f42e69b
--- /dev/null
+++ b/drivers/usb/host/ehci-mxc.c
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2008 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
+ * Copyright (c) 2009 Daniel Mack <daniel@caiaq.de>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/usb/otg.h>
+#include <linux/slab.h>
+
+#include <mach/mxc_ehci.h>
+
+#define ULPI_VIEWPORT_OFFSET    0x170
+#define PORTSC_OFFSET           0x184
+#define USBMODE_OFFSET          0x1a8
+#define USBMODE_CM_HOST         3
+
+struct ehci_mxc_priv {
+        struct clk *usbclk, *ahbclk;
+        struct usb_hcd *hcd;
+};
+
+/* called during probe() after chip reset completes */
+static int ehci_mxc_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+
+        /* EHCI registers start at offset 0x100 */
+        ehci->caps = hcd->regs + 0x100;
+        ehci->regs = hcd->regs + 0x100 +
+            HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        /* data structure init */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        hcd->has_tt = 1;
+
+        ehci->sbrn = 0x20;
+
+        ehci_reset(ehci);
+
+        ehci_port_power(ehci, 0);
+        return 0;
+}
+
+static const struct hc_driver ehci_mxc_hc_driver = {
+        .description = hcd_name,
+        .product_desc = "Freescale On-Chip EHCI Host Controller",
+        .hcd_priv_size = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq = ehci_irq,
+        .flags = HCD_USB2 | HCD_MEMORY,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset = ehci_mxc_setup,
+        .start = ehci_run,
+        .stop = ehci_stop,
+        .shutdown = ehci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue = ehci_urb_enqueue,
+        .urb_dequeue = ehci_urb_dequeue,
+        .endpoint_disable = ehci_endpoint_disable,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data = ehci_hub_status_data,
+        .hub_control = ehci_hub_control,
+        .bus_suspend = ehci_bus_suspend,
+        .bus_resume = ehci_bus_resume,
+        .relinquish_port = ehci_relinquish_port,
+        .port_handed_over = ehci_port_handed_over,
+};
+
+static int ehci_mxc_drv_probe(struct platform_device *pdev)
+{
+        struct mxc_usbh_platform_data *pdata = pdev->dev.platform_data;
+        struct usb_hcd *hcd;
+        struct resource *res;
+        int irq, ret, temp;
+        struct ehci_mxc_priv *priv;
+        struct device *dev = &pdev->dev;
+
+        dev_info(&pdev->dev, "initializing i.MX USB Controller\n");
+
+        if (!pdata) {
+                dev_err(dev, "No platform data given, bailing out.\n");
+                return -EINVAL;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+
+        hcd = usb_create_hcd(&ehci_mxc_hc_driver, dev, dev_name(dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                ret = -ENOMEM;
+                goto err_alloc;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "Found HC with no register addr. Check setup!\n");
+                ret = -ENODEV;
+                goto err_get_resource;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                dev_dbg(dev, "controller already in use\n");
+                ret = -EBUSY;
+                goto err_request_mem;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_err(dev, "error mapping memory\n");
+                ret = -EFAULT;
+                goto err_ioremap;
+        }
+
+        /* call platform specific init function */
+        if (pdata->init) {
+                ret = pdata->init(pdev);
+                if (ret) {
+                        dev_err(dev, "platform init failed\n");
+                        goto err_init;
+                }
+                /* platforms need some time to settle changed IO settings */
+                mdelay(10);
+        }
+
+        /* enable clocks */
+        priv->usbclk = clk_get(dev, "usb");
+        if (IS_ERR(priv->usbclk)) {
+                ret = PTR_ERR(priv->usbclk);
+                goto err_clk;
+        }
+        clk_enable(priv->usbclk);
+
+        if (!cpu_is_mx35()) {
+                priv->ahbclk = clk_get(dev, "usb_ahb");
+                if (IS_ERR(priv->ahbclk)) {
+                        ret = PTR_ERR(priv->ahbclk);
+                        goto err_clk_ahb;
+                }
+                clk_enable(priv->ahbclk);
+        }
+
+        /* set USBMODE to host mode */
+        temp = readl(hcd->regs + USBMODE_OFFSET);
+        writel(temp | USBMODE_CM_HOST, hcd->regs + USBMODE_OFFSET);
+
+        /* set up the PORTSCx register */
+        writel(pdata->portsc, hcd->regs + PORTSC_OFFSET);
+        mdelay(10);
+
+        /* setup USBCONTROL. */
+        ret = mxc_set_usbcontrol(pdev->id, pdata->flags);
+        if (ret < 0)
+                goto err_init;
+
+        /* Initialize the transceiver */
+        if (pdata->otg) {
+                pdata->otg->io_priv = hcd->regs + ULPI_VIEWPORT_OFFSET;
+                if (otg_init(pdata->otg) != 0)
+                        dev_err(dev, "unable to init transceiver\n");
+                else if (otg_set_vbus(pdata->otg, 1) != 0)
+                        dev_err(dev, "unable to enable vbus on transceiver\n");
+        }
+
+        priv->hcd = hcd;
+        platform_set_drvdata(pdev, priv);
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (ret)
+                goto err_add;
+
+        return 0;
+
+err_add:
+        if (pdata && pdata->exit)
+                pdata->exit(pdev);
+err_init:
+        if (priv->ahbclk) {
+                clk_disable(priv->ahbclk);
+                clk_put(priv->ahbclk);
+        }
+err_clk_ahb:
+        clk_disable(priv->usbclk);
+        clk_put(priv->usbclk);
+err_clk:
+        iounmap(hcd->regs);
+err_ioremap:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_request_mem:
+err_get_resource:
+        kfree(priv);
+err_alloc:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int __exit ehci_mxc_drv_remove(struct platform_device *pdev)
+{
+        struct mxc_usbh_platform_data *pdata = pdev->dev.platform_data;
+        struct ehci_mxc_priv *priv = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = priv->hcd;
+
+        if (pdata && pdata->exit)
+                pdata->exit(pdev);
+
+        if (pdata->otg)
+                otg_shutdown(pdata->otg);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        platform_set_drvdata(pdev, NULL);
+
+        clk_disable(priv->usbclk);
+        clk_put(priv->usbclk);
+        if (priv->ahbclk) {
+                clk_disable(priv->ahbclk);
+                clk_put(priv->ahbclk);
+        }
+
+        kfree(priv);
+
+        return 0;
+}
+
+static void ehci_mxc_drv_shutdown(struct platform_device *pdev)
+{
+        struct ehci_mxc_priv *priv = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = priv->hcd;
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+MODULE_ALIAS("platform:mxc-ehci");
+
+static struct platform_driver ehci_mxc_driver = {
+        .probe = ehci_mxc_drv_probe,
+        .remove = __exit_p(ehci_mxc_drv_remove),
+        .shutdown = ehci_mxc_drv_shutdown,
+        .driver = {
+                   .name = "mxc-ehci",
+        },
+};
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
new file mode 100644
index 000000000000..40a858335035
--- /dev/null
+++ b/drivers/usb/host/ehci-omap.c
@@ -0,0 +1,794 @@
+/*
+ * ehci-omap.c - driver for USBHOST on OMAP 34xx processor
+ *
+ * Bus Glue for OMAP34xx USBHOST 3 port EHCI controller
+ * Tested on OMAP3430 ES2.0 SDP
+ *
+ * Copyright (C) 2007-2008 Texas Instruments, Inc.
+ *      Author: Vikram Pandita <vikram.pandita@ti.com>
+ *
+ * Copyright (C) 2009 Nokia Corporation
+ *      Contact: Felipe Balbi <felipe.balbi@nokia.com>
+ *
+ * Based on "ehci-fsl.c" and "ehci-au1xxx.c" ehci glue layers
+ *
+ * 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
+ *
+ * TODO (last updated Feb 12, 2010):
+ *      - add kernel-doc
+ *      - enable AUTOIDLE
+ *      - add suspend/resume
+ *      - move workarounds to board-files
+ */
+
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/gpio.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <plat/usb.h>
+
+/*
+ * OMAP USBHOST Register addresses: VIRTUAL ADDRESSES
+ *      Use ehci_omap_readl()/ehci_omap_writel() functions
+ */
+
+/* TLL Register Set */
+#define OMAP_USBTLL_REVISION                            (0x00)
+#define OMAP_USBTLL_SYSCONFIG                           (0x10)
+#define OMAP_USBTLL_SYSCONFIG_CACTIVITY                 (1 << 8)
+#define OMAP_USBTLL_SYSCONFIG_SIDLEMODE                 (1 << 3)
+#define OMAP_USBTLL_SYSCONFIG_ENAWAKEUP                 (1 << 2)
+#define OMAP_USBTLL_SYSCONFIG_SOFTRESET                 (1 << 1)
+#define OMAP_USBTLL_SYSCONFIG_AUTOIDLE                  (1 << 0)
+
+#define OMAP_USBTLL_SYSSTATUS                           (0x14)
+#define OMAP_USBTLL_SYSSTATUS_RESETDONE                 (1 << 0)
+
+#define OMAP_USBTLL_IRQSTATUS                           (0x18)
+#define OMAP_USBTLL_IRQENABLE                           (0x1C)
+
+#define OMAP_TLL_SHARED_CONF                            (0x30)
+#define OMAP_TLL_SHARED_CONF_USB_90D_DDR_EN             (1 << 6)
+#define OMAP_TLL_SHARED_CONF_USB_180D_SDR_EN            (1 << 5)
+#define OMAP_TLL_SHARED_CONF_USB_DIVRATION              (1 << 2)
+#define OMAP_TLL_SHARED_CONF_FCLK_REQ                   (1 << 1)
+#define OMAP_TLL_SHARED_CONF_FCLK_IS_ON                 (1 << 0)
+
+#define OMAP_TLL_CHANNEL_CONF(num)                      (0x040 + 0x004 * num)
+#define OMAP_TLL_CHANNEL_CONF_ULPINOBITSTUFF            (1 << 11)
+#define OMAP_TLL_CHANNEL_CONF_ULPI_ULPIAUTOIDLE         (1 << 10)
+#define OMAP_TLL_CHANNEL_CONF_UTMIAUTOIDLE              (1 << 9)
+#define OMAP_TLL_CHANNEL_CONF_ULPIDDRMODE               (1 << 8)
+#define OMAP_TLL_CHANNEL_CONF_CHANEN                    (1 << 0)
+
+#define OMAP_TLL_ULPI_FUNCTION_CTRL(num)                (0x804 + 0x100 * num)
+#define OMAP_TLL_ULPI_INTERFACE_CTRL(num)               (0x807 + 0x100 * num)
+#define OMAP_TLL_ULPI_OTG_CTRL(num)                     (0x80A + 0x100 * num)
+#define OMAP_TLL_ULPI_INT_EN_RISE(num)                  (0x80D + 0x100 * num)
+#define OMAP_TLL_ULPI_INT_EN_FALL(num)                  (0x810 + 0x100 * num)
+#define OMAP_TLL_ULPI_INT_STATUS(num)                   (0x813 + 0x100 * num)
+#define OMAP_TLL_ULPI_INT_LATCH(num)                    (0x814 + 0x100 * num)
+#define OMAP_TLL_ULPI_DEBUG(num)                        (0x815 + 0x100 * num)
+#define OMAP_TLL_ULPI_SCRATCH_REGISTER(num)             (0x816 + 0x100 * num)
+
+#define OMAP_TLL_CHANNEL_COUNT                          3
+#define OMAP_TLL_CHANNEL_1_EN_MASK                      (1 << 1)
+#define OMAP_TLL_CHANNEL_2_EN_MASK                      (1 << 2)
+#define OMAP_TLL_CHANNEL_3_EN_MASK                      (1 << 4)
+
+/* UHH Register Set */
+#define OMAP_UHH_REVISION                               (0x00)
+#define OMAP_UHH_SYSCONFIG                              (0x10)
+#define OMAP_UHH_SYSCONFIG_MIDLEMODE                    (1 << 12)
+#define OMAP_UHH_SYSCONFIG_CACTIVITY                    (1 << 8)
+#define OMAP_UHH_SYSCONFIG_SIDLEMODE                    (1 << 3)
+#define OMAP_UHH_SYSCONFIG_ENAWAKEUP                    (1 << 2)
+#define OMAP_UHH_SYSCONFIG_SOFTRESET                    (1 << 1)
+#define OMAP_UHH_SYSCONFIG_AUTOIDLE                     (1 << 0)
+
+#define OMAP_UHH_SYSSTATUS                              (0x14)
+#define OMAP_UHH_HOSTCONFIG                             (0x40)
+#define OMAP_UHH_HOSTCONFIG_ULPI_BYPASS                 (1 << 0)
+#define OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS              (1 << 0)
+#define OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS              (1 << 11)
+#define OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS              (1 << 12)
+#define OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN              (1 << 2)
+#define OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN              (1 << 3)
+#define OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN             (1 << 4)
+#define OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN              (1 << 5)
+#define OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS           (1 << 8)
+#define OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS           (1 << 9)
+#define OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS           (1 << 10)
+
+#define OMAP_UHH_DEBUG_CSR                              (0x44)
+
+/* EHCI Register Set */
+#define EHCI_INSNREG05_ULPI                             (0xA4)
+#define EHCI_INSNREG05_ULPI_CONTROL_SHIFT               31
+#define EHCI_INSNREG05_ULPI_PORTSEL_SHIFT               24
+#define EHCI_INSNREG05_ULPI_OPSEL_SHIFT                 22
+#define EHCI_INSNREG05_ULPI_REGADD_SHIFT                16
+#define EHCI_INSNREG05_ULPI_EXTREGADD_SHIFT             8
+#define EHCI_INSNREG05_ULPI_WRDATA_SHIFT                0
+
+/*-------------------------------------------------------------------------*/
+
+static inline void ehci_omap_writel(void __iomem *base, u32 reg, u32 val)
+{
+        __raw_writel(val, base + reg);
+}
+
+static inline u32 ehci_omap_readl(void __iomem *base, u32 reg)
+{
+        return __raw_readl(base + reg);
+}
+
+static inline void ehci_omap_writeb(void __iomem *base, u8 reg, u8 val)
+{
+        __raw_writeb(val, base + reg);
+}
+
+static inline u8 ehci_omap_readb(void __iomem *base, u8 reg)
+{
+        return __raw_readb(base + reg);
+}
+
+/*-------------------------------------------------------------------------*/
+
+struct ehci_hcd_omap {
+        struct ehci_hcd         *ehci;
+        struct device           *dev;
+
+        struct clk              *usbhost_ick;
+        struct clk              *usbhost2_120m_fck;
+        struct clk              *usbhost1_48m_fck;
+        struct clk              *usbtll_fck;
+        struct clk              *usbtll_ick;
+
+        /* FIXME the following two workarounds are
+         * board specific not silicon-specific so these
+         * should be moved to board-file instead.
+         *
+         * Maybe someone from TI will know better which
+         * board is affected and needs the workarounds
+         * to be applied
+         */
+
+        /* gpio for resetting phy */
+        int                     reset_gpio_port[OMAP3_HS_USB_PORTS];
+
+        /* phy reset workaround */
+        int                     phy_reset;
+
+        /* desired phy_mode: TLL, PHY */
+        enum ehci_hcd_omap_mode port_mode[OMAP3_HS_USB_PORTS];
+
+        void __iomem            *uhh_base;
+        void __iomem            *tll_base;
+        void __iomem            *ehci_base;
+
+        /* Regulators for USB PHYs.
+         * Each PHY can have a seperate regulator.
+         */
+        struct regulator        *regulator[OMAP3_HS_USB_PORTS];
+};
+
+/*-------------------------------------------------------------------------*/
+
+static void omap_usb_utmi_init(struct ehci_hcd_omap *omap, u8 tll_channel_mask)
+{
+        unsigned reg;
+        int i;
+
+        /* Program the 3 TLL channels upfront */
+        for (i = 0; i < OMAP_TLL_CHANNEL_COUNT; i++) {
+                reg = ehci_omap_readl(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i));
+
+                /* Disable AutoIdle, BitStuffing and use SDR Mode */
+                reg &= ~(OMAP_TLL_CHANNEL_CONF_UTMIAUTOIDLE
+                                | OMAP_TLL_CHANNEL_CONF_ULPINOBITSTUFF
+                                | OMAP_TLL_CHANNEL_CONF_ULPIDDRMODE);
+                ehci_omap_writel(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i), reg);
+        }
+
+        /* Program Common TLL register */
+        reg = ehci_omap_readl(omap->tll_base, OMAP_TLL_SHARED_CONF);
+        reg |= (OMAP_TLL_SHARED_CONF_FCLK_IS_ON
+                        | OMAP_TLL_SHARED_CONF_USB_DIVRATION
+                        | OMAP_TLL_SHARED_CONF_USB_180D_SDR_EN);
+        reg &= ~OMAP_TLL_SHARED_CONF_USB_90D_DDR_EN;
+
+        ehci_omap_writel(omap->tll_base, OMAP_TLL_SHARED_CONF, reg);
+
+        /* Enable channels now */
+        for (i = 0; i < OMAP_TLL_CHANNEL_COUNT; i++) {
+                reg = ehci_omap_readl(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i));
+
+                /* Enable only the reg that is needed */
+                if (!(tll_channel_mask & 1<<i))
+                        continue;
+
+                reg |= OMAP_TLL_CHANNEL_CONF_CHANEN;
+                ehci_omap_writel(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i), reg);
+
+                ehci_omap_writeb(omap->tll_base,
+                                OMAP_TLL_ULPI_SCRATCH_REGISTER(i), 0xbe);
+                dev_dbg(omap->dev, "ULPI_SCRATCH_REG[ch=%d]= 0x%02x\n",
+                                i+1, ehci_omap_readb(omap->tll_base,
+                                OMAP_TLL_ULPI_SCRATCH_REGISTER(i)));
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* omap_start_ehc
+ *      - Start the TI USBHOST controller
+ */
+static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
+{
+        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
+        u8 tll_ch_mask = 0;
+        unsigned reg = 0;
+        int ret = 0;
+
+        dev_dbg(omap->dev, "starting TI EHCI USB Controller\n");
+
+        /* Enable Clocks for USBHOST */
+        omap->usbhost_ick = clk_get(omap->dev, "usbhost_ick");
+        if (IS_ERR(omap->usbhost_ick)) {
+                ret =  PTR_ERR(omap->usbhost_ick);
+                goto err_host_ick;
+        }
+        clk_enable(omap->usbhost_ick);
+
+        omap->usbhost2_120m_fck = clk_get(omap->dev, "usbhost_120m_fck");
+        if (IS_ERR(omap->usbhost2_120m_fck)) {
+                ret = PTR_ERR(omap->usbhost2_120m_fck);
+                goto err_host_120m_fck;
+        }
+        clk_enable(omap->usbhost2_120m_fck);
+
+        omap->usbhost1_48m_fck = clk_get(omap->dev, "usbhost_48m_fck");
+        if (IS_ERR(omap->usbhost1_48m_fck)) {
+                ret = PTR_ERR(omap->usbhost1_48m_fck);
+                goto err_host_48m_fck;
+        }
+        clk_enable(omap->usbhost1_48m_fck);
+
+        if (omap->phy_reset) {
+                /* Refer: ISSUE1 */
+                if (gpio_is_valid(omap->reset_gpio_port[0])) {
+                        gpio_request(omap->reset_gpio_port[0],
+                                                "USB1 PHY reset");
+                        gpio_direction_output(omap->reset_gpio_port[0], 0);
+                }
+
+                if (gpio_is_valid(omap->reset_gpio_port[1])) {
+                        gpio_request(omap->reset_gpio_port[1],
+                                                "USB2 PHY reset");
+                        gpio_direction_output(omap->reset_gpio_port[1], 0);
+                }
+
+                /* Hold the PHY in RESET for enough time till DIR is high */
+                udelay(10);
+        }
+
+        /* Configure TLL for 60Mhz clk for ULPI */
+        omap->usbtll_fck = clk_get(omap->dev, "usbtll_fck");
+        if (IS_ERR(omap->usbtll_fck)) {
+                ret = PTR_ERR(omap->usbtll_fck);
+                goto err_tll_fck;
+        }
+        clk_enable(omap->usbtll_fck);
+
+        omap->usbtll_ick = clk_get(omap->dev, "usbtll_ick");
+        if (IS_ERR(omap->usbtll_ick)) {
+                ret = PTR_ERR(omap->usbtll_ick);
+                goto err_tll_ick;
+        }
+        clk_enable(omap->usbtll_ick);
+
+        /* perform TLL soft reset, and wait until reset is complete */
+        ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG,
+                        OMAP_USBTLL_SYSCONFIG_SOFTRESET);
+
+        /* Wait for TLL reset to complete */
+        while (!(ehci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS)
+                        & OMAP_USBTLL_SYSSTATUS_RESETDONE)) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout)) {
+                        dev_dbg(omap->dev, "operation timed out\n");
+                        ret = -EINVAL;
+                        goto err_sys_status;
+                }
+        }
+
+        dev_dbg(omap->dev, "TLL RESET DONE\n");
+
+        /* (1<<3) = no idle mode only for initial debugging */
+        ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG,
+                        OMAP_USBTLL_SYSCONFIG_ENAWAKEUP |
+                        OMAP_USBTLL_SYSCONFIG_SIDLEMODE |
+                        OMAP_USBTLL_SYSCONFIG_CACTIVITY);
+
+
+        /* Put UHH in NoIdle/NoStandby mode */
+        reg = ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSCONFIG);
+        reg |= (OMAP_UHH_SYSCONFIG_ENAWAKEUP
+                        | OMAP_UHH_SYSCONFIG_SIDLEMODE
+                        | OMAP_UHH_SYSCONFIG_CACTIVITY
+                        | OMAP_UHH_SYSCONFIG_MIDLEMODE);
+        reg &= ~OMAP_UHH_SYSCONFIG_AUTOIDLE;
+
+        ehci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG, reg);
+
+        reg = ehci_omap_readl(omap->uhh_base, OMAP_UHH_HOSTCONFIG);
+
+        /* setup ULPI bypass and burst configurations */
+        reg |= (OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN
+                        | OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN
+                        | OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN);
+        reg &= ~OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN;
+
+        if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_UNKNOWN)
+                reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS;
+        if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_UNKNOWN)
+                reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS;
+        if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_UNKNOWN)
+                reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS;
+
+        /* Bypass the TLL module for PHY mode operation */
+         if (omap_rev() <= OMAP3430_REV_ES2_1) {
+                dev_dbg(omap->dev, "OMAP3 ES version <= ES2.1 \n");
+                if ((omap->port_mode[0] == EHCI_HCD_OMAP_MODE_PHY) ||
+                        (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_PHY) ||
+                                (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_PHY))
+                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
+                else
+                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
+        } else {
+                dev_dbg(omap->dev, "OMAP3 ES version > ES2.1\n");
+                if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_PHY)
+                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
+                else if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL)
+                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
+
+                if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_PHY)
+                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
+                else if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL)
+                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
+
+                if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_PHY)
+                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
+                else if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL)
+                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
+
+        }
+        ehci_omap_writel(omap->uhh_base, OMAP_UHH_HOSTCONFIG, reg);
+        dev_dbg(omap->dev, "UHH setup done, uhh_hostconfig=%x\n", reg);
+
+
+        if ((omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL) ||
+                (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL) ||
+                        (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL)) {
+
+                if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL)
+                        tll_ch_mask |= OMAP_TLL_CHANNEL_1_EN_MASK;
+                if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL)
+                        tll_ch_mask |= OMAP_TLL_CHANNEL_2_EN_MASK;
+                if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL)
+                        tll_ch_mask |= OMAP_TLL_CHANNEL_3_EN_MASK;
+
+                /* Enable UTMI mode for required TLL channels */
+                omap_usb_utmi_init(omap, tll_ch_mask);
+        }
+
+        if (omap->phy_reset) {
+                /* Refer ISSUE1:
+                 * Hold the PHY in RESET for enough time till
+                 * PHY is settled and ready
+                 */
+                udelay(10);
+
+                if (gpio_is_valid(omap->reset_gpio_port[0]))
+                        gpio_set_value(omap->reset_gpio_port[0], 1);
+
+                if (gpio_is_valid(omap->reset_gpio_port[1]))
+                        gpio_set_value(omap->reset_gpio_port[1], 1);
+        }
+
+        return 0;
+
+err_sys_status:
+        clk_disable(omap->usbtll_ick);
+        clk_put(omap->usbtll_ick);
+
+err_tll_ick:
+        clk_disable(omap->usbtll_fck);
+        clk_put(omap->usbtll_fck);
+
+err_tll_fck:
+        clk_disable(omap->usbhost1_48m_fck);
+        clk_put(omap->usbhost1_48m_fck);
+
+        if (omap->phy_reset) {
+                if (gpio_is_valid(omap->reset_gpio_port[0]))
+                        gpio_free(omap->reset_gpio_port[0]);
+
+                if (gpio_is_valid(omap->reset_gpio_port[1]))
+                        gpio_free(omap->reset_gpio_port[1]);
+        }
+
+err_host_48m_fck:
+        clk_disable(omap->usbhost2_120m_fck);
+        clk_put(omap->usbhost2_120m_fck);
+
+err_host_120m_fck:
+        clk_disable(omap->usbhost_ick);
+        clk_put(omap->usbhost_ick);
+
+err_host_ick:
+        return ret;
+}
+
+static void omap_stop_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
+{
+        unsigned long timeout = jiffies + msecs_to_jiffies(100);
+
+        dev_dbg(omap->dev, "stopping TI EHCI USB Controller\n");
+
+        /* Reset OMAP modules for insmod/rmmod to work */
+        ehci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG,
+                        OMAP_UHH_SYSCONFIG_SOFTRESET);
+        while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
+                                & (1 << 0))) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout))
+                        dev_dbg(omap->dev, "operation timed out\n");
+        }
+
+        while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
+                                & (1 << 1))) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout))
+                        dev_dbg(omap->dev, "operation timed out\n");
+        }
+
+        while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
+                                & (1 << 2))) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout))
+                        dev_dbg(omap->dev, "operation timed out\n");
+        }
+
+        ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG, (1 << 1));
+
+        while (!(ehci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS)
+                                & (1 << 0))) {
+                cpu_relax();
+
+                if (time_after(jiffies, timeout))
+                        dev_dbg(omap->dev, "operation timed out\n");
+        }
+
+        if (omap->usbtll_fck != NULL) {
+                clk_disable(omap->usbtll_fck);
+                clk_put(omap->usbtll_fck);
+                omap->usbtll_fck = NULL;
+        }
+
+        if (omap->usbhost_ick != NULL) {
+                clk_disable(omap->usbhost_ick);
+                clk_put(omap->usbhost_ick);
+                omap->usbhost_ick = NULL;
+        }
+
+        if (omap->usbhost1_48m_fck != NULL) {
+                clk_disable(omap->usbhost1_48m_fck);
+                clk_put(omap->usbhost1_48m_fck);
+                omap->usbhost1_48m_fck = NULL;
+        }
+
+        if (omap->usbhost2_120m_fck != NULL) {
+                clk_disable(omap->usbhost2_120m_fck);
+                clk_put(omap->usbhost2_120m_fck);
+                omap->usbhost2_120m_fck = NULL;
+        }
+
+        if (omap->usbtll_ick != NULL) {
+                clk_disable(omap->usbtll_ick);
+                clk_put(omap->usbtll_ick);
+                omap->usbtll_ick = NULL;
+        }
+
+        if (omap->phy_reset) {
+                if (gpio_is_valid(omap->reset_gpio_port[0]))
+                        gpio_free(omap->reset_gpio_port[0]);
+
+                if (gpio_is_valid(omap->reset_gpio_port[1]))
+                        gpio_free(omap->reset_gpio_port[1]);
+        }
+
+        dev_dbg(omap->dev, "Clock to USB host has been disabled\n");
+}
+
+/*-------------------------------------------------------------------------*/
+
+static const struct hc_driver ehci_omap_hc_driver;
+
+/* configure so an HC device and id are always provided */
+/* always called with process context; sleeping is OK */
+
+/**
+ * ehci_hcd_omap_probe - initialize TI-based HCDs
+ *
+ * Allocates basic resources for this USB host controller, and
+ * then invokes the start() method for the HCD associated with it
+ * through the hotplug entry's driver_data.
+ */
+static int ehci_hcd_omap_probe(struct platform_device *pdev)
+{
+        struct ehci_hcd_omap_platform_data *pdata = pdev->dev.platform_data;
+        struct ehci_hcd_omap *omap;
+        struct resource *res;
+        struct usb_hcd *hcd;
+
+        int irq = platform_get_irq(pdev, 0);
+        int ret = -ENODEV;
+        int i;
+        char supply[7];
+
+        if (!pdata) {
+                dev_dbg(&pdev->dev, "missing platform_data\n");
+                goto err_pdata;
+        }
+
+        if (usb_disabled())
+                goto err_disabled;
+
+        omap = kzalloc(sizeof(*omap), GFP_KERNEL);
+        if (!omap) {
+                ret = -ENOMEM;
+                goto err_disabled;
+        }
+
+        hcd = usb_create_hcd(&ehci_omap_hc_driver, &pdev->dev,
+                        dev_name(&pdev->dev));
+        if (!hcd) {
+                dev_dbg(&pdev->dev, "failed to create hcd with err %d\n", ret);
+                ret = -ENOMEM;
+                goto err_create_hcd;
+        }
+
+        platform_set_drvdata(pdev, omap);
+        omap->dev               = &pdev->dev;
+        omap->phy_reset         = pdata->phy_reset;
+        omap->reset_gpio_port[0]        = pdata->reset_gpio_port[0];
+        omap->reset_gpio_port[1]        = pdata->reset_gpio_port[1];
+        omap->reset_gpio_port[2]        = pdata->reset_gpio_port[2];
+        omap->port_mode[0]              = pdata->port_mode[0];
+        omap->port_mode[1]              = pdata->port_mode[1];
+        omap->port_mode[2]              = pdata->port_mode[2];
+        omap->ehci              = hcd_to_ehci(hcd);
+        omap->ehci->sbrn        = 0x20;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "EHCI ioremap failed\n");
+                ret = -ENOMEM;
+                goto err_ioremap;
+        }
+
+        /* we know this is the memory we want, no need to ioremap again */
+        omap->ehci->caps = hcd->regs;
+        omap->ehci_base = hcd->regs;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        omap->uhh_base = ioremap(res->start, resource_size(res));
+        if (!omap->uhh_base) {
+                dev_err(&pdev->dev, "UHH ioremap failed\n");
+                ret = -ENOMEM;
+                goto err_uhh_ioremap;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
+        omap->tll_base = ioremap(res->start, resource_size(res));
+        if (!omap->tll_base) {
+                dev_err(&pdev->dev, "TLL ioremap failed\n");
+                ret = -ENOMEM;
+                goto err_tll_ioremap;
+        }
+
+        /* get ehci regulator and enable */
+        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
+                if (omap->port_mode[i] != EHCI_HCD_OMAP_MODE_PHY) {
+                        omap->regulator[i] = NULL;
+                        continue;
+                }
+                snprintf(supply, sizeof(supply), "hsusb%d", i);
+                omap->regulator[i] = regulator_get(omap->dev, supply);
+                if (IS_ERR(omap->regulator[i])) {
+                        omap->regulator[i] = NULL;
+                        dev_dbg(&pdev->dev,
+                        "failed to get ehci port%d regulator\n", i);
+                } else {
+                        regulator_enable(omap->regulator[i]);
+                }
+        }
+
+        ret = omap_start_ehc(omap, hcd);
+        if (ret) {
+                dev_dbg(&pdev->dev, "failed to start ehci\n");
+                goto err_start;
+        }
+
+        omap->ehci->regs = hcd->regs
+                + HC_LENGTH(readl(&omap->ehci->caps->hc_capbase));
+
+        dbg_hcs_params(omap->ehci, "reset");
+        dbg_hcc_params(omap->ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        omap->ehci->hcs_params = readl(&omap->ehci->caps->hcs_params);
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (ret) {
+                dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
+                goto err_add_hcd;
+        }
+
+        return 0;
+
+err_add_hcd:
+        omap_stop_ehc(omap, hcd);
+
+err_start:
+        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
+                if (omap->regulator[i]) {
+                        regulator_disable(omap->regulator[i]);
+                        regulator_put(omap->regulator[i]);
+                }
+        }
+        iounmap(omap->tll_base);
+
+err_tll_ioremap:
+        iounmap(omap->uhh_base);
+
+err_uhh_ioremap:
+        iounmap(hcd->regs);
+
+err_ioremap:
+        usb_put_hcd(hcd);
+
+err_create_hcd:
+        kfree(omap);
+err_disabled:
+err_pdata:
+        return ret;
+}
+
+/* may be called without controller electrically present */
+/* may be called with controller, bus, and devices active */
+
+/**
+ * ehci_hcd_omap_remove - shutdown processing for EHCI HCDs
+ * @pdev: USB Host Controller being removed
+ *
+ * Reverses the effect of usb_ehci_hcd_omap_probe(), first invoking
+ * the HCD's stop() method.  It is always called from a thread
+ * context, normally "rmmod", "apmd", or something similar.
+ */
+static int ehci_hcd_omap_remove(struct platform_device *pdev)
+{
+        struct ehci_hcd_omap *omap = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ehci_to_hcd(omap->ehci);
+        int i;
+
+        usb_remove_hcd(hcd);
+        omap_stop_ehc(omap, hcd);
+        iounmap(hcd->regs);
+        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
+                if (omap->regulator[i]) {
+                        regulator_disable(omap->regulator[i]);
+                        regulator_put(omap->regulator[i]);
+                }
+        }
+        iounmap(omap->tll_base);
+        iounmap(omap->uhh_base);
+        usb_put_hcd(hcd);
+        kfree(omap);
+
+        return 0;
+}
+
+static void ehci_hcd_omap_shutdown(struct platform_device *pdev)
+{
+        struct ehci_hcd_omap *omap = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = ehci_to_hcd(omap->ehci);
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+static struct platform_driver ehci_hcd_omap_driver = {
+        .probe                  = ehci_hcd_omap_probe,
+        .remove                 = ehci_hcd_omap_remove,
+        .shutdown               = ehci_hcd_omap_shutdown,
+        /*.suspend              = ehci_hcd_omap_suspend, */
+        /*.resume               = ehci_hcd_omap_resume, */
+        .driver = {
+                .name           = "ehci-omap",
+        }
+};
+
+/*-------------------------------------------------------------------------*/
+
+static const struct hc_driver ehci_omap_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "OMAP-EHCI Host Controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                  = ehci_init,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+};
+
+MODULE_ALIAS("platform:omap-ehci");
+MODULE_AUTHOR("Texas Instruments, Inc.");
+MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>");
+
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index 1d283e1b2b8d..0f87dc72820a 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -222,14 +222,14 @@ static int __devinit ehci_orion_drv_probe(struct platform_device *pdev)
                 goto err1;
         }
 
-        if (!request_mem_region(res->start, res->end - res->start + 1,
+        if (!request_mem_region(res->start, resource_size(res),
                                 ehci_orion_hc_driver.description)) {
                 dev_dbg(&pdev->dev, "controller already in use\n");
                 err = -EBUSY;
                 goto err1;
         }
 
-        regs = ioremap(res->start, res->end - res->start + 1);
+        regs = ioremap(res->start, resource_size(res));
         if (regs == NULL) {
                 dev_dbg(&pdev->dev, "error mapping memory\n");
                 err = -EFAULT;
@@ -244,7 +244,7 @@ static int __devinit ehci_orion_drv_probe(struct platform_device *pdev)
         }
 
         hcd->rsrc_start = res->start;
-        hcd->rsrc_len = res->end - res->start + 1;
+        hcd->rsrc_len = resource_size(res);
         hcd->regs = regs;
 
         ehci = hcd_to_ehci(hcd);
@@ -287,7 +287,7 @@ err4:
 err3:
         iounmap(regs);
 err2:
-        release_mem_region(res->start, res->end - res->start + 1);
+        release_mem_region(res->start, resource_size(res));
 err1:
         dev_err(&pdev->dev, "init %s fail, %d\n",
                 dev_name(&pdev->dev), err);
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index 36f96da129f5..8df33b8a634c 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -134,21 +134,21 @@ ehci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
         hcd->rsrc_len = res.end - res.start + 1;
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                printk(KERN_ERR __FILE__ ": request_mem_region failed\n");
+                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
                 rv = -EBUSY;
                 goto err_rmr;
         }
 
         irq = irq_of_parse_and_map(dn, 0);
         if (irq == NO_IRQ) {
-                printk(KERN_ERR __FILE__ ": irq_of_parse_and_map failed\n");
+                printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
                 rv = -EBUSY;
                 goto err_irq;
         }
 
         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
         if (!hcd->regs) {
-                printk(KERN_ERR __FILE__ ": ioremap failed\n");
+                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
                 rv = -ENOMEM;
                 goto err_ioremap;
         }
@@ -161,9 +161,9 @@ ehci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
                         ehci->ohci_hcctrl_reg = ioremap(res.start +
                                         OHCI_HCCTRL_OFFSET, OHCI_HCCTRL_LEN);
                 else
-                        pr_debug(__FILE__ ": no ohci offset in fdt\n");
+                        pr_debug("%s: no ohci offset in fdt\n", __FILE__);
                 if (!ehci->ohci_hcctrl_reg) {
-                        pr_debug(__FILE__ ": ioremap for ohci hcctrl failed\n");
+                        pr_debug("%s: ioremap for ohci hcctrl failed\n", __FILE__);
                 } else {
                         ehci->has_amcc_usb23 = 1;
                 }
@@ -241,7 +241,7 @@ static int ehci_hcd_ppc_of_remove(struct of_device *op)
                                 else
                                         release_mem_region(res.start, 0x4);
                         else
-                                pr_debug(__FILE__ ": no ohci offset in fdt\n");
+                                pr_debug("%s: no ohci offset in fdt\n", __FILE__);
                         of_node_put(np);
                 }
 
@@ -264,7 +264,7 @@ static int ehci_hcd_ppc_of_shutdown(struct of_device *op)
 }
 
 
-static struct of_device_id ehci_hcd_ppc_of_match[] = {
+static const struct of_device_id ehci_hcd_ppc_of_match[] = {
         {
                 .compatible = "usb-ehci",
         },
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 139a2cc3f641..89521775c567 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -616,9 +616,11 @@ qh_urb_transaction (
 ) {
         struct ehci_qtd         *qtd, *qtd_prev;
         dma_addr_t              buf;
-        int                     len, maxpacket;
+        int                     len, this_sg_len, maxpacket;
         int                     is_input;
         u32                     token;
+        int                     i;
+        struct scatterlist      *sg;
 
         /*
          * URBs map to sequences of QTDs:  one logical transaction
@@ -659,7 +661,20 @@ qh_urb_transaction (
         /*
          * data transfer stage:  buffer setup
          */
-        buf = urb->transfer_dma;
+        i = urb->num_sgs;
+        if (len > 0 && i > 0) {
+                sg = urb->sg->sg;
+                buf = sg_dma_address(sg);
+
+                /* urb->transfer_buffer_length may be smaller than the
+                 * size of the scatterlist (or vice versa)
+                 */
+                this_sg_len = min_t(int, sg_dma_len(sg), len);
+        } else {
+                sg = NULL;
+                buf = urb->transfer_dma;
+                this_sg_len = len;
+        }
 
         if (is_input)
                 token |= (1 /* "in" */ << 8);
@@ -675,7 +690,9 @@ qh_urb_transaction (
         for (;;) {
                 int this_qtd_len;
 
-                this_qtd_len = qtd_fill(ehci, qtd, buf, len, token, maxpacket);
+                this_qtd_len = qtd_fill(ehci, qtd, buf, this_sg_len, token,
+                                maxpacket);
+                this_sg_len -= this_qtd_len;
                 len -= this_qtd_len;
                 buf += this_qtd_len;
 
@@ -691,8 +708,13 @@ qh_urb_transaction (
                 if ((maxpacket & (this_qtd_len + (maxpacket - 1))) == 0)
                         token ^= QTD_TOGGLE;
 
-                if (likely (len <= 0))
-                        break;
+                if (likely(this_sg_len <= 0)) {
+                        if (--i <= 0 || len <= 0)
+                                break;
+                        sg = sg_next(sg);
+                        buf = sg_dma_address(sg);
+                        this_sg_len = min_t(int, sg_dma_len(sg), len);
+                }
 
                 qtd_prev = qtd;
                 qtd = ehci_qtd_alloc (ehci, flags);
@@ -827,9 +849,10 @@ qh_make (
                                  * But interval 1 scheduling is simpler, and
                                  * includes high bandwidth.
                                  */
-                                dbg ("intr period %d uframes, NYET!",
-                                                urb->interval);
-                                goto done;
+                                urb->interval = 1;
+                        } else if (qh->period > ehci->periodic_size) {
+                                qh->period = ehci->periodic_size;
+                                urb->interval = qh->period << 3;
                         }
                 } else {
                         int             think_time;
@@ -852,6 +875,10 @@ qh_make (
                                         usb_calc_bus_time (urb->dev->speed,
                                         is_input, 0, max_packet (maxp)));
                         qh->period = urb->interval;
+                        if (qh->period > ehci->periodic_size) {
+                                qh->period = ehci->periodic_size;
+                                urb->interval = qh->period;
+                        }
                 }
         }
 
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index a5535b5e3fe2..805ec633a652 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -510,6 +510,8 @@ static int disable_periodic (struct ehci_hcd *ehci)
         ehci_writel(ehci, cmd, &ehci->regs->command);
         /* posted write ... */
 
+        free_cached_lists(ehci);
+
         ehci->next_uframe = -1;
         return 0;
 }
@@ -1121,8 +1123,8 @@ iso_stream_find (struct ehci_hcd *ehci, struct urb *urb)
                                         urb->interval);
                 }
 
-        /* if dev->ep [epnum] is a QH, info1.maxpacket is nonzero */
-        } else if (unlikely (stream->hw_info1 != 0)) {
+        /* if dev->ep [epnum] is a QH, hw is set */
+        } else if (unlikely (stream->hw != NULL)) {
                 ehci_dbg (ehci, "dev %s ep%d%s, not iso??\n",
                         urb->dev->devpath, epnum,
                         usb_pipein(urb->pipe) ? "in" : "out");
@@ -1385,7 +1387,7 @@ sitd_slot_ok (
  * given EHCI_TUNE_FLS and the slop).  Or, write a smarter scheduler!
  */
 
-#define SCHEDULE_SLOP   10      /* frames */
+#define SCHEDULE_SLOP   80      /* microframes */
 
 static int
 iso_stream_schedule (
@@ -1394,12 +1396,13 @@ iso_stream_schedule (
         struct ehci_iso_stream  *stream
 )
 {
-        u32                     now, start, max, period;
+        u32                     now, next, start, period;
         int                     status;
         unsigned                mod = ehci->periodic_size << 3;
         struct ehci_iso_sched   *sched = urb->hcpriv;
+        struct pci_dev          *pdev;
 
-        if (sched->span > (mod - 8 * SCHEDULE_SLOP)) {
+        if (sched->span > (mod - SCHEDULE_SLOP)) {
                 ehci_dbg (ehci, "iso request %p too long\n", urb);
                 status = -EFBIG;
                 goto fail;
@@ -1418,26 +1421,35 @@ iso_stream_schedule (
 
         now = ehci_readl(ehci, &ehci->regs->frame_index) % mod;
 
-        /* when's the last uframe this urb could start? */
-        max = now + mod;
-
         /* 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))) {
+                pdev = to_pci_dev(ehci_to_hcd(ehci)->self.controller);
                 start = stream->next_uframe;
-                if (start < now)
-                        start += mod;
+
+                /* For high speed devices, allow scheduling within the
+                 * isochronous scheduling threshold.  For full speed devices,
+                 * don't. (Work around for Intel ICH9 bug.)
+                 */
+                if (!stream->highspeed &&
+                                pdev->vendor == PCI_VENDOR_ID_INTEL)
+                        next = now + ehci->i_thresh;
+                else
+                        next = now;
 
                 /* Fell behind (by up to twice the slop amount)? */
-                if (start >= max - 2 * 8 * SCHEDULE_SLOP)
+                if (((start - next) & (mod - 1)) >=
+                                mod - 2 * SCHEDULE_SLOP)
                         start += period * DIV_ROUND_UP(
-                                        max - start, period) - mod;
+                                        (next - start) & (mod - 1),
+                                        period);
 
                 /* Tried to schedule too far into the future? */
-                if (unlikely((start + sched->span) >= max)) {
+                if (unlikely(((start - now) & (mod - 1)) + sched->span
+                                        >= mod - 2 * SCHEDULE_SLOP)) {
                         status = -EFBIG;
                         goto fail;
                 }
@@ -1451,7 +1463,7 @@ iso_stream_schedule (
          * can also help high bandwidth if the dma and irq loads don't
          * jump until after the queue is primed.
          */
-        start = SCHEDULE_SLOP * 8 + (now & ~0x07);
+        start = SCHEDULE_SLOP + (now & ~0x07);
         start %= mod;
         stream->next_uframe = start;
 
@@ -1482,7 +1494,7 @@ iso_stream_schedule (
         /* no room in the schedule */
         ehci_dbg (ehci, "iso %ssched full %p (now %d max %d)\n",
                 list_empty (&stream->td_list) ? "" : "re",
-                urb, now, max);
+                urb, now, now + mod);
         status = -ENOSPC;
 
 fail:
@@ -1553,13 +1565,27 @@ itd_patch(
 static inline void
 itd_link (struct ehci_hcd *ehci, unsigned frame, struct ehci_itd *itd)
 {
-        /* always prepend ITD/SITD ... only QH tree is order-sensitive */
-        itd->itd_next = ehci->pshadow [frame];
-        itd->hw_next = ehci->periodic [frame];
-        ehci->pshadow [frame].itd = itd;
+        union ehci_shadow       *prev = &ehci->pshadow[frame];
+        __hc32                  *hw_p = &ehci->periodic[frame];
+        union ehci_shadow       here = *prev;
+        __hc32                  type = 0;
+
+        /* skip any iso nodes which might belong to previous microframes */
+        while (here.ptr) {
+                type = Q_NEXT_TYPE(ehci, *hw_p);
+                if (type == cpu_to_hc32(ehci, Q_TYPE_QH))
+                        break;
+                prev = periodic_next_shadow(ehci, prev, type);
+                hw_p = shadow_next_periodic(ehci, &here, type);
+                here = *prev;
+        }
+
+        itd->itd_next = here;
+        itd->hw_next = *hw_p;
+        prev->itd = itd;
         itd->frame = frame;
         wmb ();
-        ehci->periodic[frame] = cpu_to_hc32(ehci, itd->itd_dma | Q_TYPE_ITD);
+        *hw_p = cpu_to_hc32(ehci, itd->itd_dma | Q_TYPE_ITD);
 }
 
 /* fit urb's itds into the selected schedule slot; activate as needed */
@@ -2113,13 +2139,27 @@ sitd_complete (
                         (stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out");
         }
         iso_stream_put (ehci, stream);
-        /* OK to recycle this SITD now that its completion callback ran. */
+
 done:
         sitd->urb = NULL;
-        sitd->stream = NULL;
-        list_move(&sitd->sitd_list, &stream->free_list);
-        iso_stream_put(ehci, stream);
-
+        if (ehci->clock_frame != sitd->frame) {
+                /* OK to recycle this SITD now. */
+                sitd->stream = NULL;
+                list_move(&sitd->sitd_list, &stream->free_list);
+                iso_stream_put(ehci, stream);
+        } else {
+                /* HW might remember this SITD, so we can't recycle it yet.
+                 * Move it to a safe place until a new frame starts.
+                 */
+                list_move(&sitd->sitd_list, &ehci->cached_sitd_list);
+                if (stream->refcount == 2) {
+                        /* If iso_stream_put() were called here, stream
+                         * would be freed.  Instead, just prevent reuse.
+                         */
+                        stream->ep->hcpriv = NULL;
+                        stream->ep = NULL;
+                }
+        }
         return retval;
 }
 
@@ -2185,9 +2225,10 @@ done:
 
 /*-------------------------------------------------------------------------*/
 
-static void free_cached_itd_list(struct ehci_hcd *ehci)
+static void free_cached_lists(struct ehci_hcd *ehci)
 {
         struct ehci_itd *itd, *n;
+        struct ehci_sitd *sitd, *sn;
 
         list_for_each_entry_safe(itd, n, &ehci->cached_itd_list, itd_list) {
                 struct ehci_iso_stream  *stream = itd->stream;
@@ -2195,6 +2236,13 @@ static void free_cached_itd_list(struct ehci_hcd *ehci)
                 list_move(&itd->itd_list, &stream->free_list);
                 iso_stream_put(ehci, stream);
         }
+
+        list_for_each_entry_safe(sitd, sn, &ehci->cached_sitd_list, sitd_list) {
+                struct ehci_iso_stream  *stream = sitd->stream;
+                sitd->stream = NULL;
+                list_move(&sitd->sitd_list, &stream->free_list);
+                iso_stream_put(ehci, stream);
+        }
 }
 
 /*-------------------------------------------------------------------------*/
@@ -2221,7 +2269,7 @@ scan_periodic (struct ehci_hcd *ehci)
                 clock_frame = -1;
         }
         if (ehci->clock_frame != clock_frame) {
-                free_cached_itd_list(ehci);
+                free_cached_lists(ehci);
                 ehci->clock_frame = clock_frame;
         }
         clock %= mod;
@@ -2312,9 +2360,13 @@ restart:
                                  * No need to check for activity unless the
                                  * frame is current.
                                  */
-                                if (frame == clock_frame && live &&
-                                                (q.sitd->hw_results &
-                                                        SITD_ACTIVE(ehci))) {
+                                if (((frame == clock_frame) ||
+                                     (((frame + 1) % ehci->periodic_size)
+                                      == clock_frame))
+                                    && live
+                                    && (q.sitd->hw_results &
+                                        SITD_ACTIVE(ehci))) {
+
                                         incomplete = true;
                                         q_p = &q.sitd->sitd_next;
                                         hw_p = &q.sitd->hw_next;
@@ -2384,7 +2436,7 @@ restart:
                         clock = now;
                         clock_frame = clock >> 3;
                         if (ehci->clock_frame != clock_frame) {
-                                free_cached_itd_list(ehci);
+                                free_cached_lists(ehci);
                                 ehci->clock_frame = clock_frame;
                         }
                 } else {
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
new file mode 100644
index 000000000000..f603bb2c0a8e
--- /dev/null
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -0,0 +1,300 @@
+/*
+ * EHCI HCD (Host Controller Driver) for USB.
+ *
+ * Bus Glue for Xilinx EHCI core on the of_platform bus
+ *
+ * Copyright (c) 2009 Xilinx, Inc.
+ *
+ * Based on "ehci-ppc-of.c" by Valentine Barshak <vbarshak@ru.mvista.com>
+ * and "ehci-ppc-soc.c" by Stefan Roese <sr@denx.de>
+ * and "ohci-ppc-of.c" by Sylvain Munaut <tnt@246tNt.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <linux/signal.h>
+
+#include <linux/of.h>
+#include <linux/of_platform.h>
+
+/**
+ * ehci_xilinx_of_setup - Initialize the device for ehci_reset()
+ * @hcd:        Pointer to the usb_hcd device to which the host controller bound
+ *
+ * called during probe() after chip reset completes.
+ */
+static int ehci_xilinx_of_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int             retval;
+
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci->sbrn = 0x20;
+
+        return ehci_reset(ehci);
+}
+
+/**
+ * ehci_xilinx_port_handed_over - hand the port out if failed to enable it
+ * @hcd:        Pointer to the usb_hcd device to which the host controller bound
+ * @portnum:Port number to which the device is attached.
+ *
+ * This function is used as a place to tell the user that the Xilinx USB host
+ * controller does support LS devices. And in an HS only configuration, it
+ * does not support FS devices either. It is hoped that this can help a
+ * confused user.
+ *
+ * There are cases when the host controller fails to enable the port due to,
+ * for example, insufficient power that can be supplied to the device from
+ * the USB bus. In those cases, the messages printed here are not helpful.
+ */
+static int ehci_xilinx_port_handed_over(struct usb_hcd *hcd, int portnum)
+{
+        dev_warn(hcd->self.controller, "port %d cannot be enabled\n", portnum);
+        if (hcd->has_tt) {
+                dev_warn(hcd->self.controller,
+                        "Maybe you have connected a low speed device?\n");
+
+                dev_warn(hcd->self.controller,
+                        "We do not support low speed devices\n");
+        } else {
+                dev_warn(hcd->self.controller,
+                        "Maybe your device is not a high speed device?\n");
+                dev_warn(hcd->self.controller,
+                        "The USB host controller does not support full speed "
+                        "nor low speed devices\n");
+                dev_warn(hcd->self.controller,
+                        "You can reconfigure the host controller to have "
+                        "full speed support\n");
+        }
+
+        return 0;
+}
+
+
+static const struct hc_driver ehci_xilinx_of_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "OF EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                  = ehci_xilinx_of_setup,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+#ifdef  CONFIG_PM
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+#endif
+        .relinquish_port        = NULL,
+        .port_handed_over       = ehci_xilinx_port_handed_over,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+};
+
+/**
+ * ehci_hcd_xilinx_of_probe - Probe method for the USB host controller
+ * @op:         pointer to the of_device to which the host controller bound
+ * @match:      pointer to of_device_id structure, not used
+ *
+ * This function requests resources and sets up appropriate properties for the
+ * host controller. Because the Xilinx USB host controller can be configured
+ * as HS only or HS/FS only, it checks the configuration in the device tree
+ * entry, and sets an appropriate value for hcd->has_tt.
+ */
+static int __devinit
+ehci_hcd_xilinx_of_probe(struct of_device *op, const struct of_device_id *match)
+{
+        struct device_node *dn = op->node;
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci;
+        struct resource res;
+        int irq;
+        int rv;
+        int *value;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        dev_dbg(&op->dev, "initializing XILINX-OF USB Controller\n");
+
+        rv = of_address_to_resource(dn, 0, &res);
+        if (rv)
+                return rv;
+
+        hcd = usb_create_hcd(&ehci_xilinx_of_hc_driver, &op->dev,
+                                "XILINX-OF USB");
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res.start;
+        hcd->rsrc_len = res.end - res.start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_rmr;
+        }
+
+        irq = irq_of_parse_and_map(dn, 0);
+        if (irq == NO_IRQ) {
+                printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
+                rv = -EBUSY;
+                goto err_irq;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
+                rv = -ENOMEM;
+                goto err_ioremap;
+        }
+
+        ehci = hcd_to_ehci(hcd);
+
+        /* This core always has big-endian register interface and uses
+         * big-endian memory descriptors.
+         */
+        ehci->big_endian_mmio = 1;
+        ehci->big_endian_desc = 1;
+
+        /* Check whether the FS support option is selected in the hardware.
+         */
+        value = (int *)of_get_property(dn, "xlnx,support-usb-fs", NULL);
+        if (value && (*value == 1)) {
+                ehci_dbg(ehci, "USB host controller supports FS devices\n");
+                hcd->has_tt = 1;
+        } else {
+                ehci_dbg(ehci,
+                        "USB host controller is HS only\n");
+                hcd->has_tt = 0;
+        }
+
+        /* Debug registers are at the first 0x100 region
+         */
+        ehci->caps = hcd->regs + 0x100;
+        ehci->regs = hcd->regs + 0x100 +
+                        HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        rv = usb_add_hcd(hcd, irq, 0);
+        if (rv == 0)
+                return 0;
+
+        iounmap(hcd->regs);
+
+err_ioremap:
+err_irq:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_rmr:
+        usb_put_hcd(hcd);
+
+        return rv;
+}
+
+/**
+ * ehci_hcd_xilinx_of_remove - shutdown hcd and release resources
+ * @op:         pointer to of_device structure that is to be removed
+ *
+ * Remove the hcd structure, and release resources that has been requested
+ * during probe.
+ */
+static int ehci_hcd_xilinx_of_remove(struct of_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+        dev_set_drvdata(&op->dev, NULL);
+
+        dev_dbg(&op->dev, "stopping XILINX-OF USB Controller\n");
+
+        usb_remove_hcd(hcd);
+
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+/**
+ * ehci_hcd_xilinx_of_shutdown - shutdown the hcd
+ * @op:         pointer to of_device structure that is to be removed
+ *
+ * Properly shutdown the hcd, call driver's shutdown routine.
+ */
+static int ehci_hcd_xilinx_of_shutdown(struct of_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+
+        return 0;
+}
+
+
+static const struct of_device_id ehci_hcd_xilinx_of_match[] = {
+                {.compatible = "xlnx,xps-usb-host-1.00.a",},
+        {},
+};
+MODULE_DEVICE_TABLE(of, ehci_hcd_xilinx_of_match);
+
+static struct of_platform_driver ehci_hcd_xilinx_of_driver = {
+        .name           = "xilinx-of-ehci",
+        .match_table    = ehci_hcd_xilinx_of_match,
+        .probe          = ehci_hcd_xilinx_of_probe,
+        .remove         = ehci_hcd_xilinx_of_remove,
+        .shutdown       = ehci_hcd_xilinx_of_shutdown,
+        .driver         = {
+                .name   = "xilinx-of-ehci",
+                .owner  = THIS_MODULE,
+        },
+};
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 2d85e21ff282..556c0b48f3ab 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -87,8 +87,9 @@ struct ehci_hcd {			/* one per controller */
         int                     next_uframe;    /* scan periodic, start here */
         unsigned                periodic_sched; /* periodic activity count */
 
-        /* list of itds completed while clock_frame was still active */
+        /* list of itds & sitds completed while clock_frame was still active */
         struct list_head        cached_itd_list;
+        struct list_head        cached_sitd_list;
         unsigned                clock_frame;
 
         /* per root hub port */
@@ -195,7 +196,7 @@ timer_action_done (struct ehci_hcd *ehci, enum ehci_timer_action action)
         clear_bit (action, &ehci->actions);
 }
 
-static void free_cached_itd_list(struct ehci_hcd *ehci);
+static void free_cached_lists(struct ehci_hcd *ehci);
 
 /*-------------------------------------------------------------------------*/
 
@@ -394,9 +395,8 @@ struct ehci_iso_sched {
  * acts like a qh would, if EHCI had them for ISO.
  */
 struct ehci_iso_stream {
-        /* first two fields match QH, but info1 == 0 */
-        __hc32                  hw_next;
-        __hc32                  hw_info1;
+        /* first field matches ehci_hq, but is NULL */
+        struct ehci_qh_hw       *hw;
 
         u32                     refcount;
         u8                      bEndpointAddress;
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 0951818ef93b..15379c636143 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -27,6 +27,7 @@
 #include <linux/usb.h>
 #include <linux/of_platform.h>
 #include <linux/of_gpio.h>
+#include <linux/slab.h>
 #include <asm/qe.h>
 #include <asm/fsl_gtm.h>
 #include "../core/hcd.h"
@@ -242,9 +243,10 @@ err:
 static void fhci_usb_free(void *lld)
 {
         struct fhci_usb *usb = lld;
-        struct fhci_hcd *fhci = usb->fhci;
+        struct fhci_hcd *fhci;
 
         if (usb) {
+                fhci = usb->fhci;
                 fhci_config_transceiver(fhci, FHCI_PORT_POWER_OFF);
                 fhci_ep0_free(usb);
                 kfree(usb->actual_frame);
@@ -432,7 +434,7 @@ static int fhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
                 return -ENOMEM;
 
         /* allocate the private part of the URB */
-        urb_priv->tds = kzalloc(size * sizeof(struct td), mem_flags);
+        urb_priv->tds = kcalloc(size, sizeof(*urb_priv->tds), mem_flags);
         if (!urb_priv->tds) {
                 kfree(urb_priv);
                 return -ENOMEM;
@@ -804,7 +806,7 @@ static int __devexit of_fhci_remove(struct of_device *ofdev)
         return fhci_remove(&ofdev->dev);
 }
 
-static struct of_device_id of_fhci_match[] = {
+static const struct of_device_id of_fhci_match[] = {
         { .compatible = "fsl,mpc8323-qe-usb", },
         {},
 };
diff --git a/drivers/usb/host/fhci-mem.c b/drivers/usb/host/fhci-mem.c
index 2c0736c99712..5591bfb499d1 100644
--- a/drivers/usb/host/fhci-mem.c
+++ b/drivers/usb/host/fhci-mem.c
@@ -18,6 +18,7 @@
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/usb.h>
 #include "../core/hcd.h"
diff --git a/drivers/usb/host/fhci-q.c b/drivers/usb/host/fhci-q.c
index b0a1446ba292..f73c92359beb 100644
--- a/drivers/usb/host/fhci-q.c
+++ b/drivers/usb/host/fhci-q.c
@@ -19,6 +19,7 @@
 #include <linux/types.h>
 #include <linux/spinlock.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/usb.h>
 #include "../core/hcd.h"
diff --git a/drivers/usb/host/fhci-sched.c b/drivers/usb/host/fhci-sched.c
index 62a226b61670..ff43747a614f 100644
--- a/drivers/usb/host/fhci-sched.c
+++ b/drivers/usb/host/fhci-sched.c
@@ -37,7 +37,7 @@ static void recycle_frame(struct fhci_usb *usb, struct packet *pkt)
         pkt->info = 0;
         pkt->priv_data = NULL;
 
-        cq_put(usb->ep0->empty_frame_Q, pkt);
+        cq_put(&usb->ep0->empty_frame_Q, pkt);
 }
 
 /* confirm submitted packet */
@@ -57,7 +57,7 @@ void fhci_transaction_confirm(struct fhci_usb *usb, struct packet *pkt)
                 if ((td->data + td->actual_len) && trans_len)
                         memcpy(td->data + td->actual_len, pkt->data,
                                trans_len);
-                cq_put(usb->ep0->dummy_packets_Q, pkt->data);
+                cq_put(&usb->ep0->dummy_packets_Q, pkt->data);
         }
 
         recycle_frame(usb, pkt);
@@ -213,7 +213,7 @@ static int add_packet(struct fhci_usb *usb, struct ed *ed, struct td *td)
         }
 
         /* update frame object fields before transmitting */
-        pkt = cq_get(usb->ep0->empty_frame_Q);
+        pkt = cq_get(&usb->ep0->empty_frame_Q);
         if (!pkt) {
                 fhci_dbg(usb->fhci, "there is no empty frame\n");
                 return -1;
@@ -222,7 +222,7 @@ static int add_packet(struct fhci_usb *usb, struct ed *ed, struct td *td)
 
         pkt->info = 0;
         if (data == NULL) {
-                data = cq_get(usb->ep0->dummy_packets_Q);
+                data = cq_get(&usb->ep0->dummy_packets_Q);
                 BUG_ON(!data);
                 pkt->info = PKT_DUMMY_PACKET;
         }
@@ -246,7 +246,7 @@ static int add_packet(struct fhci_usb *usb, struct ed *ed, struct td *td)
                 list_del_init(&td->frame_lh);
                 td->status = USB_TD_OK;
                 if (pkt->info & PKT_DUMMY_PACKET)
-                        cq_put(usb->ep0->dummy_packets_Q, pkt->data);
+                        cq_put(&usb->ep0->dummy_packets_Q, pkt->data);
                 recycle_frame(usb, pkt);
                 usb->actual_frame->total_bytes -= (len + PROTOCOL_OVERHEAD);
                 fhci_err(usb->fhci, "host transaction failed\n");
@@ -627,7 +627,7 @@ irqreturn_t fhci_irq(struct usb_hcd *hcd)
 
 
 /*
- * Process normal completions(error or sucess) and clean the schedule.
+ * Process normal completions(error or success) and clean the schedule.
  *
  * This is the main path for handing urbs back to drivers. The only other patth
  * is process_del_list(),which unlinks URBs by scanning EDs,instead of scanning
diff --git a/drivers/usb/host/fhci-tds.c b/drivers/usb/host/fhci-tds.c
index b40332290319..57013479d7f7 100644
--- a/drivers/usb/host/fhci-tds.c
+++ b/drivers/usb/host/fhci-tds.c
@@ -18,6 +18,7 @@
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/io.h>
 #include <linux/usb.h>
@@ -105,34 +106,34 @@ void fhci_ep0_free(struct fhci_usb *usb)
                 if (ep->td_base)
                         cpm_muram_free(cpm_muram_offset(ep->td_base));
 
-                if (ep->conf_frame_Q) {
-                        size = cq_howmany(ep->conf_frame_Q);
+                if (kfifo_initialized(&ep->conf_frame_Q)) {
+                        size = cq_howmany(&ep->conf_frame_Q);
                         for (; size; size--) {
-                                struct packet *pkt = cq_get(ep->conf_frame_Q);
+                                struct packet *pkt = cq_get(&ep->conf_frame_Q);
 
                                 kfree(pkt);
                         }
-                        cq_delete(ep->conf_frame_Q);
+                        cq_delete(&ep->conf_frame_Q);
                 }
 
-                if (ep->empty_frame_Q) {
-                        size = cq_howmany(ep->empty_frame_Q);
+                if (kfifo_initialized(&ep->empty_frame_Q)) {
+                        size = cq_howmany(&ep->empty_frame_Q);
                         for (; size; size--) {
-                                struct packet *pkt = cq_get(ep->empty_frame_Q);
+                                struct packet *pkt = cq_get(&ep->empty_frame_Q);
 
                                 kfree(pkt);
                         }
-                        cq_delete(ep->empty_frame_Q);
+                        cq_delete(&ep->empty_frame_Q);
                 }
 
-                if (ep->dummy_packets_Q) {
-                        size = cq_howmany(ep->dummy_packets_Q);
+                if (kfifo_initialized(&ep->dummy_packets_Q)) {
+                        size = cq_howmany(&ep->dummy_packets_Q);
                         for (; size; size--) {
-                                u8 *buff = cq_get(ep->dummy_packets_Q);
+                                u8 *buff = cq_get(&ep->dummy_packets_Q);
 
                                 kfree(buff);
                         }
-                        cq_delete(ep->dummy_packets_Q);
+                        cq_delete(&ep->dummy_packets_Q);
                 }
 
                 kfree(ep);
@@ -175,10 +176,9 @@ u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
         ep->td_base = cpm_muram_addr(ep_offset);
 
         /* zero all queue pointers */
-        ep->conf_frame_Q = cq_new(ring_len + 2);
-        ep->empty_frame_Q = cq_new(ring_len + 2);
-        ep->dummy_packets_Q = cq_new(ring_len + 2);
-        if (!ep->conf_frame_Q || !ep->empty_frame_Q || !ep->dummy_packets_Q) {
+        if (cq_new(&ep->conf_frame_Q, ring_len + 2) ||
+            cq_new(&ep->empty_frame_Q, ring_len + 2) ||
+            cq_new(&ep->dummy_packets_Q, ring_len + 2)) {
                 err_for = "frame_queues";
                 goto err;
         }
@@ -199,8 +199,8 @@ u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
                         err_for = "buffer";
                         goto err;
                 }
-                cq_put(ep->empty_frame_Q, pkt);
-                cq_put(ep->dummy_packets_Q, buff);
+                cq_put(&ep->empty_frame_Q, pkt);
+                cq_put(&ep->dummy_packets_Q, buff);
         }
 
         /* we put the endpoint parameter RAM right behind the TD ring */
@@ -319,7 +319,7 @@ static void fhci_td_transaction_confirm(struct fhci_usb *usb)
                 if ((buf == DUMMY2_BD_BUFFER) && !(td_status & ~TD_W))
                         continue;
 
-                pkt = cq_get(ep->conf_frame_Q);
+                pkt = cq_get(&ep->conf_frame_Q);
                 if (!pkt)
                         fhci_err(usb->fhci, "no frame to confirm\n");
 
@@ -460,9 +460,9 @@ u32 fhci_host_transaction(struct fhci_usb *usb,
                 out_be16(&td->length, pkt->len);
 
         /* put the frame to the confirmation queue */
-        cq_put(ep->conf_frame_Q, pkt);
+        cq_put(&ep->conf_frame_Q, pkt);
 
-        if (cq_howmany(ep->conf_frame_Q) == 1)
+        if (cq_howmany(&ep->conf_frame_Q) == 1)
                 out_8(&usb->fhci->regs->usb_comm, USB_CMD_STR_FIFO);
 
         return 0;
diff --git a/drivers/usb/host/fhci.h b/drivers/usb/host/fhci.h
index 7116284ed21a..72dae1c5ab38 100644
--- a/drivers/usb/host/fhci.h
+++ b/drivers/usb/host/fhci.h
@@ -423,9 +423,9 @@ struct endpoint {
         struct usb_td __iomem *td_base; /* first TD in the ring */
         struct usb_td __iomem *conf_td; /* next TD for confirm after transac */
         struct usb_td __iomem *empty_td;/* next TD for new transaction req. */
-        struct kfifo *empty_frame_Q;  /* Empty frames list to use */
-        struct kfifo *conf_frame_Q;   /* frames passed to TDs,waiting for tx */
-        struct kfifo *dummy_packets_Q;/* dummy packets for the CRC overun */
+        struct kfifo empty_frame_Q;  /* Empty frames list to use */
+        struct kfifo conf_frame_Q;   /* frames passed to TDs,waiting for tx */
+        struct kfifo dummy_packets_Q;/* dummy packets for the CRC overun */
 
         bool already_pushed_dummy_bd;
 };
@@ -493,9 +493,9 @@ static inline struct usb_hcd *fhci_to_hcd(struct fhci_hcd *fhci)
 }
 
 /* fifo of pointers */
-static inline struct kfifo *cq_new(int size)
+static inline int cq_new(struct kfifo *fifo, int size)
 {
-        return kfifo_alloc(size * sizeof(void *), GFP_KERNEL, NULL);
+        return kfifo_alloc(fifo, size * sizeof(void *), GFP_KERNEL);
 }
 
 static inline void cq_delete(struct kfifo *kfifo)
@@ -505,19 +505,19 @@ static inline void cq_delete(struct kfifo *kfifo)
 
 static inline unsigned int cq_howmany(struct kfifo *kfifo)
 {
-        return __kfifo_len(kfifo) / sizeof(void *);
+        return kfifo_len(kfifo) / sizeof(void *);
 }
 
 static inline int cq_put(struct kfifo *kfifo, void *p)
 {
-        return __kfifo_put(kfifo, (void *)&p, sizeof(p));
+        return kfifo_in(kfifo, (void *)&p, sizeof(p));
 }
 
 static inline void *cq_get(struct kfifo *kfifo)
 {
         void *p = NULL;
 
-        __kfifo_get(kfifo, (void *)&p, sizeof(p));
+        kfifo_out(kfifo, (void *)&p, sizeof(p));
         return p;
 }
 
diff --git a/drivers/usb/host/hwa-hc.c b/drivers/usb/host/hwa-hc.c
index 88b03214622b..35742f8c7cda 100644
--- a/drivers/usb/host/hwa-hc.c
+++ b/drivers/usb/host/hwa-hc.c
@@ -55,6 +55,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/workqueue.h>
 #include <linux/wait.h>
diff --git a/drivers/usb/host/imx21-dbg.c b/drivers/usb/host/imx21-dbg.c
new file mode 100644
index 000000000000..512f647448ca
--- /dev/null
+++ b/drivers/usb/host/imx21-dbg.c
@@ -0,0 +1,527 @@
+/*
+ * Copyright (c) 2009 by Martin Fuzzey
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* this file is part of imx21-hcd.c */
+
+#ifndef DEBUG
+
+static inline void create_debug_files(struct imx21 *imx21) { }
+static inline void remove_debug_files(struct imx21 *imx21) { }
+static inline void debug_urb_submitted(struct imx21 *imx21, struct urb *urb) {}
+static inline void debug_urb_completed(struct imx21 *imx21, struct urb *urb,
+        int status) {}
+static inline void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb) {}
+static inline void debug_urb_queued_for_etd(struct imx21 *imx21,
+        struct urb *urb) {}
+static inline void debug_urb_queued_for_dmem(struct imx21 *imx21,
+        struct urb *urb) {}
+static inline void debug_etd_allocated(struct imx21 *imx21) {}
+static inline void debug_etd_freed(struct imx21 *imx21) {}
+static inline void debug_dmem_allocated(struct imx21 *imx21, int size) {}
+static inline void debug_dmem_freed(struct imx21 *imx21, int size) {}
+static inline void debug_isoc_submitted(struct imx21 *imx21,
+        int frame, struct td *td) {}
+static inline void debug_isoc_completed(struct imx21 *imx21,
+        int frame, struct td *td, int cc, int len) {}
+
+#else
+
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+
+static const char *dir_labels[] = {
+        "TD 0",
+        "OUT",
+        "IN",
+        "TD 1"
+};
+
+static const char *speed_labels[] = {
+        "Full",
+        "Low"
+};
+
+static const char *format_labels[] = {
+        "Control",
+        "ISO",
+        "Bulk",
+        "Interrupt"
+};
+
+static inline struct debug_stats *stats_for_urb(struct imx21 *imx21,
+        struct urb *urb)
+{
+        return usb_pipeisoc(urb->pipe) ?
+                &imx21->isoc_stats : &imx21->nonisoc_stats;
+}
+
+static void debug_urb_submitted(struct imx21 *imx21, struct urb *urb)
+{
+        stats_for_urb(imx21, urb)->submitted++;
+}
+
+static void debug_urb_completed(struct imx21 *imx21, struct urb *urb, int st)
+{
+        if (st)
+                stats_for_urb(imx21, urb)->completed_failed++;
+        else
+                stats_for_urb(imx21, urb)->completed_ok++;
+}
+
+static void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb)
+{
+        stats_for_urb(imx21, urb)->unlinked++;
+}
+
+static void debug_urb_queued_for_etd(struct imx21 *imx21, struct urb *urb)
+{
+        stats_for_urb(imx21, urb)->queue_etd++;
+}
+
+static void debug_urb_queued_for_dmem(struct imx21 *imx21, struct urb *urb)
+{
+        stats_for_urb(imx21, urb)->queue_dmem++;
+}
+
+static inline void debug_etd_allocated(struct imx21 *imx21)
+{
+        imx21->etd_usage.maximum = max(
+                        ++(imx21->etd_usage.value),
+                        imx21->etd_usage.maximum);
+}
+
+static inline void debug_etd_freed(struct imx21 *imx21)
+{
+        imx21->etd_usage.value--;
+}
+
+static inline void debug_dmem_allocated(struct imx21 *imx21, int size)
+{
+        imx21->dmem_usage.value += size;
+        imx21->dmem_usage.maximum = max(
+                        imx21->dmem_usage.value,
+                        imx21->dmem_usage.maximum);
+}
+
+static inline void debug_dmem_freed(struct imx21 *imx21, int size)
+{
+        imx21->dmem_usage.value -= size;
+}
+
+
+static void debug_isoc_submitted(struct imx21 *imx21,
+        int frame, struct td *td)
+{
+        struct debug_isoc_trace *trace = &imx21->isoc_trace[
+                imx21->isoc_trace_index++];
+
+        imx21->isoc_trace_index %= ARRAY_SIZE(imx21->isoc_trace);
+        trace->schedule_frame = td->frame;
+        trace->submit_frame = frame;
+        trace->request_len = td->len;
+        trace->td = td;
+}
+
+static inline void debug_isoc_completed(struct imx21 *imx21,
+        int frame, struct td *td, int cc, int len)
+{
+        struct debug_isoc_trace *trace, *trace_failed;
+        int i;
+        int found = 0;
+
+        trace = imx21->isoc_trace;
+        for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++) {
+                if (trace->td == td) {
+                        trace->done_frame = frame;
+                        trace->done_len = len;
+                        trace->cc = cc;
+                        trace->td = NULL;
+                        found = 1;
+                        break;
+                }
+        }
+
+        if (found && cc) {
+                trace_failed = &imx21->isoc_trace_failed[
+                                        imx21->isoc_trace_index_failed++];
+
+                imx21->isoc_trace_index_failed %= ARRAY_SIZE(
+                                                imx21->isoc_trace_failed);
+                *trace_failed = *trace;
+        }
+}
+
+
+static char *format_ep(struct usb_host_endpoint *ep, char *buf, int bufsize)
+{
+        if (ep)
+                snprintf(buf, bufsize, "ep_%02x (type:%02X kaddr:%p)",
+                        ep->desc.bEndpointAddress,
+                        usb_endpoint_type(&ep->desc),
+                        ep);
+        else
+                snprintf(buf, bufsize, "none");
+        return buf;
+}
+
+static char *format_etd_dword0(u32 value, char *buf, int bufsize)
+{
+        snprintf(buf, bufsize,
+                "addr=%d ep=%d dir=%s speed=%s format=%s halted=%d",
+                value & 0x7F,
+                (value >> DW0_ENDPNT) & 0x0F,
+                dir_labels[(value >> DW0_DIRECT) & 0x03],
+                speed_labels[(value >> DW0_SPEED) & 0x01],
+                format_labels[(value >> DW0_FORMAT) & 0x03],
+                (value >> DW0_HALTED) & 0x01);
+        return buf;
+}
+
+static int debug_status_show(struct seq_file *s, void *v)
+{
+        struct imx21 *imx21 = s->private;
+        int etds_allocated = 0;
+        int etds_sw_busy = 0;
+        int etds_hw_busy = 0;
+        int dmem_blocks = 0;
+        int queued_for_etd = 0;
+        int queued_for_dmem = 0;
+        unsigned int dmem_bytes = 0;
+        int i;
+        struct etd_priv *etd;
+        u32 etd_enable_mask;
+        unsigned long flags;
+        struct imx21_dmem_area *dmem;
+        struct ep_priv *ep_priv;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        etd_enable_mask = readl(imx21->regs + USBH_ETDENSET);
+        for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {
+                if (etd->alloc)
+                        etds_allocated++;
+                if (etd->urb)
+                        etds_sw_busy++;
+                if (etd_enable_mask & (1<<i))
+                        etds_hw_busy++;
+        }
+
+        list_for_each_entry(dmem, &imx21->dmem_list, list) {
+                dmem_bytes += dmem->size;
+                dmem_blocks++;
+        }
+
+        list_for_each_entry(ep_priv, &imx21->queue_for_etd, queue)
+                queued_for_etd++;
+
+        list_for_each_entry(etd, &imx21->queue_for_dmem, queue)
+                queued_for_dmem++;
+
+        spin_unlock_irqrestore(&imx21->lock, flags);
+
+        seq_printf(s,
+                "Frame: %d\n"
+                "ETDs allocated: %d/%d (max=%d)\n"
+                "ETDs in use sw: %d\n"
+                "ETDs in use hw: %d\n"
+                "DMEM alocated: %d/%d (max=%d)\n"
+                "DMEM blocks: %d\n"
+                "Queued waiting for ETD: %d\n"
+                "Queued waiting for DMEM: %d\n",
+                readl(imx21->regs + USBH_FRMNUB) & 0xFFFF,
+                etds_allocated, USB_NUM_ETD, imx21->etd_usage.maximum,
+                etds_sw_busy,
+                etds_hw_busy,
+                dmem_bytes, DMEM_SIZE, imx21->dmem_usage.maximum,
+                dmem_blocks,
+                queued_for_etd,
+                queued_for_dmem);
+
+        return 0;
+}
+
+static int debug_dmem_show(struct seq_file *s, void *v)
+{
+        struct imx21 *imx21 = s->private;
+        struct imx21_dmem_area *dmem;
+        unsigned long flags;
+        char ep_text[40];
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        list_for_each_entry(dmem, &imx21->dmem_list, list)
+                seq_printf(s,
+                        "%04X: size=0x%X "
+                        "ep=%s\n",
+                        dmem->offset, dmem->size,
+                        format_ep(dmem->ep, ep_text, sizeof(ep_text)));
+
+        spin_unlock_irqrestore(&imx21->lock, flags);
+
+        return 0;
+}
+
+static int debug_etd_show(struct seq_file *s, void *v)
+{
+        struct imx21 *imx21 = s->private;
+        struct etd_priv *etd;
+        char buf[60];
+        u32 dword;
+        int i, j;
+        unsigned long flags;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {
+                int state = -1;
+                struct urb_priv *urb_priv;
+                if (etd->urb) {
+                        urb_priv = etd->urb->hcpriv;
+                        if (urb_priv)
+                                state = urb_priv->state;
+                }
+
+                seq_printf(s,
+                        "etd_num: %d\n"
+                        "ep: %s\n"
+                        "alloc: %d\n"
+                        "len: %d\n"
+                        "busy sw: %d\n"
+                        "busy hw: %d\n"
+                        "urb state: %d\n"
+                        "current urb: %p\n",
+
+                        i,
+                        format_ep(etd->ep, buf, sizeof(buf)),
+                        etd->alloc,
+                        etd->len,
+                        etd->urb != NULL,
+                        (readl(imx21->regs + USBH_ETDENSET) & (1 << i)) > 0,
+                        state,
+                        etd->urb);
+
+                for (j = 0; j < 4; j++) {
+                        dword = etd_readl(imx21, i, j);
+                        switch (j) {
+                        case 0:
+                                format_etd_dword0(dword, buf, sizeof(buf));
+                                break;
+                        case 2:
+                                snprintf(buf, sizeof(buf),
+                                        "cc=0X%02X", dword >> DW2_COMPCODE);
+                                break;
+                        default:
+                                *buf = 0;
+                                break;
+                        }
+                        seq_printf(s,
+                                "dword %d: submitted=%08X cur=%08X [%s]\n",
+                                j,
+                                etd->submitted_dwords[j],
+                                dword,
+                                buf);
+                }
+                seq_printf(s, "\n");
+        }
+
+        spin_unlock_irqrestore(&imx21->lock, flags);
+
+        return 0;
+}
+
+static void debug_statistics_show_one(struct seq_file *s,
+        const char *name, struct debug_stats *stats)
+{
+        seq_printf(s, "%s:\n"
+                "submitted URBs: %lu\n"
+                "completed OK: %lu\n"
+                "completed failed: %lu\n"
+                "unlinked: %lu\n"
+                "queued for ETD: %lu\n"
+                "queued for DMEM: %lu\n\n",
+                name,
+                stats->submitted,
+                stats->completed_ok,
+                stats->completed_failed,
+                stats->unlinked,
+                stats->queue_etd,
+                stats->queue_dmem);
+}
+
+static int debug_statistics_show(struct seq_file *s, void *v)
+{
+        struct imx21 *imx21 = s->private;
+        unsigned long flags;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        debug_statistics_show_one(s, "nonisoc", &imx21->nonisoc_stats);
+        debug_statistics_show_one(s, "isoc", &imx21->isoc_stats);
+        seq_printf(s, "unblock kludge triggers: %lu\n", imx21->debug_unblocks);
+        spin_unlock_irqrestore(&imx21->lock, flags);
+
+        return 0;
+}
+
+static void debug_isoc_show_one(struct seq_file *s,
+        const char *name, int index,    struct debug_isoc_trace *trace)
+{
+        seq_printf(s, "%s %d:\n"
+                "cc=0X%02X\n"
+                "scheduled frame %d (%d)\n"
+                "submittted frame %d (%d)\n"
+                "completed frame %d (%d)\n"
+                "requested length=%d\n"
+                "completed length=%d\n\n",
+                name, index,
+                trace->cc,
+                trace->schedule_frame, trace->schedule_frame & 0xFFFF,
+                trace->submit_frame, trace->submit_frame & 0xFFFF,
+                trace->done_frame, trace->done_frame & 0xFFFF,
+                trace->request_len,
+                trace->done_len);
+}
+
+static int debug_isoc_show(struct seq_file *s, void *v)
+{
+        struct imx21 *imx21 = s->private;
+        struct debug_isoc_trace *trace;
+        unsigned long flags;
+        int i;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        trace = imx21->isoc_trace_failed;
+        for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace_failed); i++, trace++)
+                debug_isoc_show_one(s, "isoc failed", i, trace);
+
+        trace = imx21->isoc_trace;
+        for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++)
+                debug_isoc_show_one(s, "isoc", i, trace);
+
+        spin_unlock_irqrestore(&imx21->lock, flags);
+
+        return 0;
+}
+
+static int debug_status_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, debug_status_show, inode->i_private);
+}
+
+static int debug_dmem_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, debug_dmem_show, inode->i_private);
+}
+
+static int debug_etd_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, debug_etd_show, inode->i_private);
+}
+
+static int debug_statistics_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, debug_statistics_show, inode->i_private);
+}
+
+static int debug_isoc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, debug_isoc_show, inode->i_private);
+}
+
+static const struct file_operations debug_status_fops = {
+        .open = debug_status_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static const struct file_operations debug_dmem_fops = {
+        .open = debug_dmem_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static const struct file_operations debug_etd_fops = {
+        .open = debug_etd_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static const struct file_operations debug_statistics_fops = {
+        .open = debug_statistics_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static const struct file_operations debug_isoc_fops = {
+        .open = debug_isoc_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static void create_debug_files(struct imx21 *imx21)
+{
+        imx21->debug_root = debugfs_create_dir(dev_name(imx21->dev), NULL);
+        if (!imx21->debug_root)
+                goto failed_create_rootdir;
+
+        if (!debugfs_create_file("status", S_IRUGO,
+                        imx21->debug_root, imx21, &debug_status_fops))
+                goto failed_create;
+
+        if (!debugfs_create_file("dmem", S_IRUGO,
+                        imx21->debug_root, imx21, &debug_dmem_fops))
+                goto failed_create;
+
+        if (!debugfs_create_file("etd", S_IRUGO,
+                        imx21->debug_root, imx21, &debug_etd_fops))
+                goto failed_create;
+
+        if (!debugfs_create_file("statistics", S_IRUGO,
+                        imx21->debug_root, imx21, &debug_statistics_fops))
+                goto failed_create;
+
+        if (!debugfs_create_file("isoc", S_IRUGO,
+                        imx21->debug_root, imx21, &debug_isoc_fops))
+                goto failed_create;
+
+        return;
+
+failed_create:
+        debugfs_remove_recursive(imx21->debug_root);
+
+failed_create_rootdir:
+        imx21->debug_root = NULL;
+}
+
+
+static void remove_debug_files(struct imx21 *imx21)
+{
+        if (imx21->debug_root) {
+                debugfs_remove_recursive(imx21->debug_root);
+                imx21->debug_root = NULL;
+        }
+}
+
+#endif
+
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
new file mode 100644
index 000000000000..8a12f297645f
--- /dev/null
+++ b/drivers/usb/host/imx21-hcd.c
@@ -0,0 +1,1790 @@
+/*
+ * USB Host Controller Driver for IMX21
+ *
+ * Copyright (C) 2006 Loping Dog Embedded Systems
+ * Copyright (C) 2009 Martin Fuzzey
+ * Originally written by Jay Monkman <jtm@lopingdog.com>
+ * Ported to 2.6.30, debugged and enhanced by Martin Fuzzey
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+ /*
+  * The i.MX21 USB hardware contains
+  *    * 32 transfer descriptors (called ETDs)
+  *    * 4Kb of Data memory
+  *
+  * The data memory is shared between the host and fuction controlers
+  * (but this driver only supports the host controler)
+  *
+  * So setting up a transfer involves:
+  *    * Allocating a ETD
+  *    * Fill in ETD with appropriate information
+  *    * Allocating data memory (and putting the offset in the ETD)
+  *    * Activate the ETD
+  *    * Get interrupt when done.
+  *
+  * An ETD is assigned to each active endpoint.
+  *
+  * Low resource (ETD and Data memory) situations are handled differently for
+  * isochronous and non insosynchronous transactions :
+  *
+  * Non ISOC transfers are queued if either ETDs or Data memory are unavailable
+  *
+  * ISOC transfers use 2 ETDs per endpoint to achieve double buffering.
+  * They allocate both ETDs and Data memory during URB submission
+  * (and fail if unavailable).
+  */
+
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+
+#include "../core/hcd.h"
+#include "imx21-hcd.h"
+
+#ifdef DEBUG
+#define DEBUG_LOG_FRAME(imx21, etd, event) \
+        (etd)->event##_frame = readl((imx21)->regs + USBH_FRMNUB)
+#else
+#define DEBUG_LOG_FRAME(imx21, etd, event) do { } while (0)
+#endif
+
+static const char hcd_name[] = "imx21-hcd";
+
+static inline struct imx21 *hcd_to_imx21(struct usb_hcd *hcd)
+{
+        return (struct imx21 *)hcd->hcd_priv;
+}
+
+
+/* =========================================== */
+/* Hardware access helpers                      */
+/* =========================================== */
+
+static inline void set_register_bits(struct imx21 *imx21, u32 offset, u32 mask)
+{
+        void __iomem *reg = imx21->regs + offset;
+        writel(readl(reg) | mask, reg);
+}
+
+static inline void clear_register_bits(struct imx21 *imx21,
+        u32 offset, u32 mask)
+{
+        void __iomem *reg = imx21->regs + offset;
+        writel(readl(reg) & ~mask, reg);
+}
+
+static inline void clear_toggle_bit(struct imx21 *imx21, u32 offset, u32 mask)
+{
+        void __iomem *reg = imx21->regs + offset;
+
+        if (readl(reg) & mask)
+                writel(mask, reg);
+}
+
+static inline void set_toggle_bit(struct imx21 *imx21, u32 offset, u32 mask)
+{
+        void __iomem *reg = imx21->regs + offset;
+
+        if (!(readl(reg) & mask))
+                writel(mask, reg);
+}
+
+static void etd_writel(struct imx21 *imx21, int etd_num, int dword, u32 value)
+{
+        writel(value, imx21->regs + USB_ETD_DWORD(etd_num, dword));
+}
+
+static u32 etd_readl(struct imx21 *imx21, int etd_num, int dword)
+{
+        return readl(imx21->regs + USB_ETD_DWORD(etd_num, dword));
+}
+
+static inline int wrap_frame(int counter)
+{
+        return counter & 0xFFFF;
+}
+
+static inline int frame_after(int frame, int after)
+{
+        /* handle wrapping like jiffies time_afer */
+        return (s16)((s16)after - (s16)frame) < 0;
+}
+
+static int imx21_hc_get_frame(struct usb_hcd *hcd)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+
+        return wrap_frame(readl(imx21->regs + USBH_FRMNUB));
+}
+
+
+#include "imx21-dbg.c"
+
+/* =========================================== */
+/* ETD management                               */
+/* ===========================================  */
+
+static int alloc_etd(struct imx21 *imx21)
+{
+        int i;
+        struct etd_priv *etd = imx21->etd;
+
+        for (i = 0; i < USB_NUM_ETD; i++, etd++) {
+                if (etd->alloc == 0) {
+                        memset(etd, 0, sizeof(imx21->etd[0]));
+                        etd->alloc = 1;
+                        debug_etd_allocated(imx21);
+                        return i;
+                }
+        }
+        return -1;
+}
+
+static void disactivate_etd(struct imx21 *imx21, int num)
+{
+        int etd_mask = (1 << num);
+        struct etd_priv *etd = &imx21->etd[num];
+
+        writel(etd_mask, imx21->regs + USBH_ETDENCLR);
+        clear_register_bits(imx21, USBH_ETDDONEEN, etd_mask);
+        writel(etd_mask, imx21->regs + USB_ETDDMACHANLCLR);
+        clear_toggle_bit(imx21, USBH_ETDDONESTAT, etd_mask);
+
+        etd->active_count = 0;
+
+        DEBUG_LOG_FRAME(imx21, etd, disactivated);
+}
+
+static void reset_etd(struct imx21 *imx21, int num)
+{
+        struct etd_priv *etd = imx21->etd + num;
+        int i;
+
+        disactivate_etd(imx21, num);
+
+        for (i = 0; i < 4; i++)
+                etd_writel(imx21, num, i, 0);
+        etd->urb = NULL;
+        etd->ep = NULL;
+        etd->td = NULL;;
+}
+
+static void free_etd(struct imx21 *imx21, int num)
+{
+        if (num < 0)
+                return;
+
+        if (num >= USB_NUM_ETD) {
+                dev_err(imx21->dev, "BAD etd=%d!\n", num);
+                return;
+        }
+        if (imx21->etd[num].alloc == 0) {
+                dev_err(imx21->dev, "ETD %d already free!\n", num);
+                return;
+        }
+
+        debug_etd_freed(imx21);
+        reset_etd(imx21, num);
+        memset(&imx21->etd[num], 0, sizeof(imx21->etd[0]));
+}
+
+
+static void setup_etd_dword0(struct imx21 *imx21,
+        int etd_num, struct urb *urb,  u8 dir, u16 maxpacket)
+{
+        etd_writel(imx21, etd_num, 0,
+                ((u32) usb_pipedevice(urb->pipe)) <<  DW0_ADDRESS |
+                ((u32) usb_pipeendpoint(urb->pipe) << DW0_ENDPNT) |
+                ((u32) dir << DW0_DIRECT) |
+                ((u32) ((urb->dev->speed == USB_SPEED_LOW) ?
+                        1 : 0) << DW0_SPEED) |
+                ((u32) fmt_urb_to_etd[usb_pipetype(urb->pipe)] << DW0_FORMAT) |
+                ((u32) maxpacket << DW0_MAXPKTSIZ));
+}
+
+static void activate_etd(struct imx21 *imx21,
+        int etd_num, dma_addr_t dma, u8 dir)
+{
+        u32 etd_mask = 1 << etd_num;
+        struct etd_priv *etd = &imx21->etd[etd_num];
+
+        clear_toggle_bit(imx21, USBH_ETDDONESTAT, etd_mask);
+        set_register_bits(imx21, USBH_ETDDONEEN, etd_mask);
+        clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
+        clear_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
+
+        if (dma) {
+                set_register_bits(imx21, USB_ETDDMACHANLCLR, etd_mask);
+                clear_toggle_bit(imx21, USBH_XBUFSTAT, etd_mask);
+                clear_toggle_bit(imx21, USBH_YBUFSTAT, etd_mask);
+                writel(dma, imx21->regs + USB_ETDSMSA(etd_num));
+                set_register_bits(imx21, USB_ETDDMAEN, etd_mask);
+        } else {
+                if (dir != TD_DIR_IN) {
+                        /* need to set for ZLP */
+                        set_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
+                        set_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
+                }
+        }
+
+        DEBUG_LOG_FRAME(imx21, etd, activated);
+
+#ifdef DEBUG
+        if (!etd->active_count) {
+                int i;
+                etd->activated_frame = readl(imx21->regs + USBH_FRMNUB);
+                etd->disactivated_frame = -1;
+                etd->last_int_frame = -1;
+                etd->last_req_frame = -1;
+
+                for (i = 0; i < 4; i++)
+                        etd->submitted_dwords[i] = etd_readl(imx21, etd_num, i);
+        }
+#endif
+
+        etd->active_count = 1;
+        writel(etd_mask, imx21->regs + USBH_ETDENSET);
+}
+
+/* ===========================================  */
+/* Data memory management                       */
+/* ===========================================  */
+
+static int alloc_dmem(struct imx21 *imx21, unsigned int size,
+                      struct usb_host_endpoint *ep)
+{
+        unsigned int offset = 0;
+        struct imx21_dmem_area *area;
+        struct imx21_dmem_area *tmp;
+
+        size += (~size + 1) & 0x3; /* Round to 4 byte multiple */
+
+        if (size > DMEM_SIZE) {
+                dev_err(imx21->dev, "size=%d > DMEM_SIZE(%d)\n",
+                        size, DMEM_SIZE);
+                return -EINVAL;
+        }
+
+        list_for_each_entry(tmp, &imx21->dmem_list, list) {
+                if ((size + offset) < offset)
+                        goto fail;
+                if ((size + offset) <= tmp->offset)
+                        break;
+                offset = tmp->size + tmp->offset;
+                if ((offset + size) > DMEM_SIZE)
+                        goto fail;
+        }
+
+        area = kmalloc(sizeof(struct imx21_dmem_area), GFP_ATOMIC);
+        if (area == NULL)
+                return -ENOMEM;
+
+        area->ep = ep;
+        area->offset = offset;
+        area->size = size;
+        list_add_tail(&area->list, &tmp->list);
+        debug_dmem_allocated(imx21, size);
+        return offset;
+
+fail:
+        return -ENOMEM;
+}
+
+/* Memory now available for a queued ETD - activate it */
+static void activate_queued_etd(struct imx21 *imx21,
+        struct etd_priv *etd, u32 dmem_offset)
+{
+        struct urb_priv *urb_priv = etd->urb->hcpriv;
+        int etd_num = etd - &imx21->etd[0];
+        u32 maxpacket = etd_readl(imx21, etd_num, 1) >> DW1_YBUFSRTAD;
+        u8 dir = (etd_readl(imx21, etd_num, 2) >> DW2_DIRPID) & 0x03;
+
+        dev_dbg(imx21->dev, "activating queued ETD %d now DMEM available\n",
+                etd_num);
+        etd_writel(imx21, etd_num, 1,
+            ((dmem_offset + maxpacket) << DW1_YBUFSRTAD) | dmem_offset);
+
+        urb_priv->active = 1;
+        activate_etd(imx21, etd_num, etd->dma_handle, dir);
+}
+
+static void free_dmem(struct imx21 *imx21, int offset)
+{
+        struct imx21_dmem_area *area;
+        struct etd_priv *etd, *tmp;
+        int found = 0;
+
+        list_for_each_entry(area, &imx21->dmem_list, list) {
+                if (area->offset == offset) {
+                        debug_dmem_freed(imx21, area->size);
+                        list_del(&area->list);
+                        kfree(area);
+                        found = 1;
+                        break;
+                }
+        }
+
+        if (!found)  {
+                dev_err(imx21->dev,
+                        "Trying to free unallocated DMEM %d\n", offset);
+                return;
+        }
+
+        /* Try again to allocate memory for anything we've queued */
+        list_for_each_entry_safe(etd, tmp, &imx21->queue_for_dmem, queue) {
+                offset = alloc_dmem(imx21, etd->dmem_size, etd->ep);
+                if (offset >= 0) {
+                        list_del(&etd->queue);
+                        activate_queued_etd(imx21, etd, (u32)offset);
+                }
+        }
+}
+
+static void free_epdmem(struct imx21 *imx21, struct usb_host_endpoint *ep)
+{
+        struct imx21_dmem_area *area, *tmp;
+
+        list_for_each_entry_safe(area, tmp, &imx21->dmem_list, list) {
+                if (area->ep == ep) {
+                        dev_err(imx21->dev,
+                                "Active DMEM %d for disabled ep=%p\n",
+                                area->offset, ep);
+                        list_del(&area->list);
+                        kfree(area);
+                }
+        }
+}
+
+
+/* ===========================================  */
+/* End handling                                 */
+/* ===========================================  */
+static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb);
+
+/* Endpoint now idle - release it's ETD(s) or asssign to queued request */
+static void ep_idle(struct imx21 *imx21, struct ep_priv *ep_priv)
+{
+        int etd_num;
+        int i;
+
+        for (i = 0; i < NUM_ISO_ETDS; i++) {
+                etd_num = ep_priv->etd[i];
+                if (etd_num < 0)
+                        continue;
+
+                ep_priv->etd[i] = -1;
+                if (list_empty(&imx21->queue_for_etd)) {
+                        free_etd(imx21, etd_num);
+                        continue;
+                }
+
+                dev_dbg(imx21->dev,
+                        "assigning idle etd %d for queued request\n", etd_num);
+                ep_priv = list_first_entry(&imx21->queue_for_etd,
+                        struct ep_priv, queue);
+                list_del(&ep_priv->queue);
+                reset_etd(imx21, etd_num);
+                ep_priv->waiting_etd = 0;
+                ep_priv->etd[i] = etd_num;
+
+                if (list_empty(&ep_priv->ep->urb_list)) {
+                        dev_err(imx21->dev, "No urb for queued ep!\n");
+                        continue;
+                }
+                schedule_nonisoc_etd(imx21, list_first_entry(
+                        &ep_priv->ep->urb_list, struct urb, urb_list));
+        }
+}
+
+static void urb_done(struct usb_hcd *hcd, struct urb *urb, int status)
+__releases(imx21->lock)
+__acquires(imx21->lock)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        struct ep_priv *ep_priv = urb->ep->hcpriv;
+        struct urb_priv *urb_priv = urb->hcpriv;
+
+        debug_urb_completed(imx21, urb, status);
+        dev_vdbg(imx21->dev, "urb %p done %d\n", urb, status);
+
+        kfree(urb_priv->isoc_td);
+        kfree(urb->hcpriv);
+        urb->hcpriv = NULL;
+        usb_hcd_unlink_urb_from_ep(hcd, urb);
+        spin_unlock(&imx21->lock);
+        usb_hcd_giveback_urb(hcd, urb, status);
+        spin_lock(&imx21->lock);
+        if (list_empty(&ep_priv->ep->urb_list))
+                ep_idle(imx21, ep_priv);
+}
+
+/* ===========================================  */
+/* ISOC Handling ...                            */
+/* ===========================================  */
+
+static void schedule_isoc_etds(struct usb_hcd *hcd,
+        struct usb_host_endpoint *ep)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        struct ep_priv *ep_priv = ep->hcpriv;
+        struct etd_priv *etd;
+        struct urb_priv *urb_priv;
+        struct td *td;
+        int etd_num;
+        int i;
+        int cur_frame;
+        u8 dir;
+
+        for (i = 0; i < NUM_ISO_ETDS; i++) {
+too_late:
+                if (list_empty(&ep_priv->td_list))
+                        break;
+
+                etd_num = ep_priv->etd[i];
+                if (etd_num < 0)
+                        break;
+
+                etd = &imx21->etd[etd_num];
+                if (etd->urb)
+                        continue;
+
+                td = list_entry(ep_priv->td_list.next, struct td, list);
+                list_del(&td->list);
+                urb_priv = td->urb->hcpriv;
+
+                cur_frame = imx21_hc_get_frame(hcd);
+                if (frame_after(cur_frame, td->frame)) {
+                        dev_dbg(imx21->dev, "isoc too late frame %d > %d\n",
+                                cur_frame, td->frame);
+                        urb_priv->isoc_status = -EXDEV;
+                        td->urb->iso_frame_desc[
+                                td->isoc_index].actual_length = 0;
+                        td->urb->iso_frame_desc[td->isoc_index].status = -EXDEV;
+                        if (--urb_priv->isoc_remaining == 0)
+                                urb_done(hcd, td->urb, urb_priv->isoc_status);
+                        goto too_late;
+                }
+
+                urb_priv->active = 1;
+                etd->td = td;
+                etd->ep = td->ep;
+                etd->urb = td->urb;
+                etd->len = td->len;
+
+                debug_isoc_submitted(imx21, cur_frame, td);
+
+                dir = usb_pipeout(td->urb->pipe) ? TD_DIR_OUT : TD_DIR_IN;
+                setup_etd_dword0(imx21, etd_num, td->urb, dir, etd->dmem_size);
+                etd_writel(imx21, etd_num, 1, etd->dmem_offset);
+                etd_writel(imx21, etd_num, 2,
+                        (TD_NOTACCESSED << DW2_COMPCODE) |
+                        ((td->frame & 0xFFFF) << DW2_STARTFRM));
+                etd_writel(imx21, etd_num, 3,
+                        (TD_NOTACCESSED << DW3_COMPCODE0) |
+                        (td->len << DW3_PKTLEN0));
+
+                activate_etd(imx21, etd_num, td->data, dir);
+        }
+}
+
+static void isoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        int etd_mask = 1 << etd_num;
+        struct urb_priv *urb_priv = urb->hcpriv;
+        struct etd_priv *etd = imx21->etd + etd_num;
+        struct td *td = etd->td;
+        struct usb_host_endpoint *ep = etd->ep;
+        int isoc_index = td->isoc_index;
+        unsigned int pipe = urb->pipe;
+        int dir_in = usb_pipein(pipe);
+        int cc;
+        int bytes_xfrd;
+
+        disactivate_etd(imx21, etd_num);
+
+        cc = (etd_readl(imx21, etd_num, 3) >> DW3_COMPCODE0) & 0xf;
+        bytes_xfrd = etd_readl(imx21, etd_num, 3) & 0x3ff;
+
+        /* Input doesn't always fill the buffer, don't generate an error
+         * when this happens.
+         */
+        if (dir_in && (cc == TD_DATAUNDERRUN))
+                cc = TD_CC_NOERROR;
+
+        if (cc == TD_NOTACCESSED)
+                bytes_xfrd = 0;
+
+        debug_isoc_completed(imx21,
+                imx21_hc_get_frame(hcd), td, cc, bytes_xfrd);
+        if (cc) {
+                urb_priv->isoc_status = -EXDEV;
+                dev_dbg(imx21->dev,
+                        "bad iso cc=0x%X frame=%d sched frame=%d "
+                        "cnt=%d len=%d urb=%p etd=%d index=%d\n",
+                        cc,  imx21_hc_get_frame(hcd), td->frame,
+                        bytes_xfrd, td->len, urb, etd_num, isoc_index);
+        }
+
+        if (dir_in)
+                clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
+
+        urb->actual_length += bytes_xfrd;
+        urb->iso_frame_desc[isoc_index].actual_length = bytes_xfrd;
+        urb->iso_frame_desc[isoc_index].status = cc_to_error[cc];
+
+        etd->td = NULL;
+        etd->urb = NULL;
+        etd->ep = NULL;
+
+        if (--urb_priv->isoc_remaining == 0)
+                urb_done(hcd, urb, urb_priv->isoc_status);
+
+        schedule_isoc_etds(hcd, ep);
+}
+
+static struct ep_priv *alloc_isoc_ep(
+        struct imx21 *imx21, struct usb_host_endpoint *ep)
+{
+        struct ep_priv *ep_priv;
+        int i;
+
+        ep_priv = kzalloc(sizeof(struct ep_priv), GFP_ATOMIC);
+        if (ep_priv == NULL)
+                return NULL;
+
+        /* Allocate the ETDs */
+        for (i = 0; i < NUM_ISO_ETDS; i++) {
+                ep_priv->etd[i] = alloc_etd(imx21);
+                if (ep_priv->etd[i] < 0) {
+                        int j;
+                        dev_err(imx21->dev, "isoc: Couldn't allocate etd\n");
+                        for (j = 0; j < i; j++)
+                                free_etd(imx21, ep_priv->etd[j]);
+                        goto alloc_etd_failed;
+                }
+                imx21->etd[ep_priv->etd[i]].ep = ep;
+        }
+
+        INIT_LIST_HEAD(&ep_priv->td_list);
+        ep_priv->ep = ep;
+        ep->hcpriv = ep_priv;
+        return ep_priv;
+
+alloc_etd_failed:
+        kfree(ep_priv);
+        return NULL;
+}
+
+static int imx21_hc_urb_enqueue_isoc(struct usb_hcd *hcd,
+                                     struct usb_host_endpoint *ep,
+                                     struct urb *urb, gfp_t mem_flags)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        struct urb_priv *urb_priv;
+        unsigned long flags;
+        struct ep_priv *ep_priv;
+        struct td *td = NULL;
+        int i;
+        int ret;
+        int cur_frame;
+        u16 maxpacket;
+
+        urb_priv = kzalloc(sizeof(struct urb_priv), mem_flags);
+        if (urb_priv == NULL)
+                return -ENOMEM;
+
+        urb_priv->isoc_td = kzalloc(
+                sizeof(struct td) * urb->number_of_packets, mem_flags);
+        if (urb_priv->isoc_td == NULL) {
+                ret = -ENOMEM;
+                goto alloc_td_failed;
+        }
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        if (ep->hcpriv == NULL) {
+                ep_priv = alloc_isoc_ep(imx21, ep);
+                if (ep_priv == NULL) {
+                        ret = -ENOMEM;
+                        goto alloc_ep_failed;
+                }
+        } else {
+                ep_priv = ep->hcpriv;
+        }
+
+        ret = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (ret)
+                goto link_failed;
+
+        urb->status = -EINPROGRESS;
+        urb->actual_length = 0;
+        urb->error_count = 0;
+        urb->hcpriv = urb_priv;
+        urb_priv->ep = ep;
+
+        /* allocate data memory for largest packets if not already done */
+        maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
+        for (i = 0; i < NUM_ISO_ETDS; i++) {
+                struct etd_priv *etd = &imx21->etd[ep_priv->etd[i]];
+
+                if (etd->dmem_size > 0 && etd->dmem_size < maxpacket) {
+                        /* not sure if this can really occur.... */
+                        dev_err(imx21->dev, "increasing isoc buffer %d->%d\n",
+                                etd->dmem_size, maxpacket);
+                        ret = -EMSGSIZE;
+                        goto alloc_dmem_failed;
+                }
+
+                if (etd->dmem_size == 0) {
+                        etd->dmem_offset = alloc_dmem(imx21, maxpacket, ep);
+                        if (etd->dmem_offset < 0) {
+                                dev_dbg(imx21->dev, "failed alloc isoc dmem\n");
+                                ret = -EAGAIN;
+                                goto alloc_dmem_failed;
+                        }
+                        etd->dmem_size = maxpacket;
+                }
+        }
+
+        /* calculate frame */
+        cur_frame = imx21_hc_get_frame(hcd);
+        if (urb->transfer_flags & URB_ISO_ASAP) {
+                if (list_empty(&ep_priv->td_list))
+                        urb->start_frame = cur_frame + 5;
+                else
+                        urb->start_frame = list_entry(
+                                ep_priv->td_list.prev,
+                                struct td, list)->frame + urb->interval;
+        }
+        urb->start_frame = wrap_frame(urb->start_frame);
+        if (frame_after(cur_frame, urb->start_frame)) {
+                dev_dbg(imx21->dev,
+                        "enqueue: adjusting iso start %d (cur=%d) asap=%d\n",
+                        urb->start_frame, cur_frame,
+                        (urb->transfer_flags & URB_ISO_ASAP) != 0);
+                urb->start_frame = wrap_frame(cur_frame + 1);
+        }
+
+        /* set up transfers */
+        td = urb_priv->isoc_td;
+        for (i = 0; i < urb->number_of_packets; i++, td++) {
+                td->ep = ep;
+                td->urb = urb;
+                td->len = urb->iso_frame_desc[i].length;
+                td->isoc_index = i;
+                td->frame = wrap_frame(urb->start_frame + urb->interval * i);
+                td->data = urb->transfer_dma + urb->iso_frame_desc[i].offset;
+                list_add_tail(&td->list, &ep_priv->td_list);
+        }
+
+        urb_priv->isoc_remaining = urb->number_of_packets;
+        dev_vdbg(imx21->dev, "setup %d packets for iso frame %d->%d\n",
+                urb->number_of_packets, urb->start_frame, td->frame);
+
+        debug_urb_submitted(imx21, urb);
+        schedule_isoc_etds(hcd, ep);
+
+        spin_unlock_irqrestore(&imx21->lock, flags);
+        return 0;
+
+alloc_dmem_failed:
+        usb_hcd_unlink_urb_from_ep(hcd, urb);
+
+link_failed:
+alloc_ep_failed:
+        spin_unlock_irqrestore(&imx21->lock, flags);
+        kfree(urb_priv->isoc_td);
+
+alloc_td_failed:
+        kfree(urb_priv);
+        return ret;
+}
+
+static void dequeue_isoc_urb(struct imx21 *imx21,
+        struct urb *urb, struct ep_priv *ep_priv)
+{
+        struct urb_priv *urb_priv = urb->hcpriv;
+        struct td *td, *tmp;
+        int i;
+
+        if (urb_priv->active) {
+                for (i = 0; i < NUM_ISO_ETDS; i++) {
+                        int etd_num = ep_priv->etd[i];
+                        if (etd_num != -1 && imx21->etd[etd_num].urb == urb) {
+                                struct etd_priv *etd = imx21->etd + etd_num;
+
+                                reset_etd(imx21, etd_num);
+                                if (etd->dmem_size)
+                                        free_dmem(imx21, etd->dmem_offset);
+                                etd->dmem_size = 0;
+                        }
+                }
+        }
+
+        list_for_each_entry_safe(td, tmp, &ep_priv->td_list, list) {
+                if (td->urb == urb) {
+                        dev_vdbg(imx21->dev, "removing td %p\n", td);
+                        list_del(&td->list);
+                }
+        }
+}
+
+/* =========================================== */
+/* NON ISOC Handling ...                        */
+/* =========================================== */
+
+static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb)
+{
+        unsigned int pipe = urb->pipe;
+        struct urb_priv *urb_priv = urb->hcpriv;
+        struct ep_priv *ep_priv = urb_priv->ep->hcpriv;
+        int state = urb_priv->state;
+        int etd_num = ep_priv->etd[0];
+        struct etd_priv *etd;
+        int dmem_offset;
+        u32 count;
+        u16 etd_buf_size;
+        u16 maxpacket;
+        u8 dir;
+        u8 bufround;
+        u8 datatoggle;
+        u8 interval = 0;
+        u8 relpolpos = 0;
+
+        if (etd_num < 0) {
+                dev_err(imx21->dev, "No valid ETD\n");
+                return;
+        }
+        if (readl(imx21->regs + USBH_ETDENSET) & (1 << etd_num))
+                dev_err(imx21->dev, "submitting to active ETD %d\n", etd_num);
+
+        etd = &imx21->etd[etd_num];
+        maxpacket = usb_maxpacket(urb->dev, pipe, usb_pipeout(pipe));
+        if (!maxpacket)
+                maxpacket = 8;
+
+        if (usb_pipecontrol(pipe) && (state != US_CTRL_DATA)) {
+                if (state == US_CTRL_SETUP) {
+                        dir = TD_DIR_SETUP;
+                        etd->dma_handle = urb->setup_dma;
+                        bufround = 0;
+                        count = 8;
+                        datatoggle = TD_TOGGLE_DATA0;
+                } else {        /* US_CTRL_ACK */
+                        dir = usb_pipeout(pipe) ? TD_DIR_IN : TD_DIR_OUT;
+                        etd->dma_handle = urb->transfer_dma;
+                        bufround = 0;
+                        count = 0;
+                        datatoggle = TD_TOGGLE_DATA1;
+                }
+        } else {
+                dir = usb_pipeout(pipe) ? TD_DIR_OUT : TD_DIR_IN;
+                bufround = (dir == TD_DIR_IN) ? 1 : 0;
+                etd->dma_handle = urb->transfer_dma;
+                if (usb_pipebulk(pipe) && (state == US_BULK0))
+                        count = 0;
+                else
+                        count = urb->transfer_buffer_length;
+
+                if (usb_pipecontrol(pipe)) {
+                        datatoggle = TD_TOGGLE_DATA1;
+                } else {
+                        if (usb_gettoggle(
+                                        urb->dev,
+                                        usb_pipeendpoint(urb->pipe),
+                                        usb_pipeout(urb->pipe)))
+                                datatoggle = TD_TOGGLE_DATA1;
+                        else
+                                datatoggle = TD_TOGGLE_DATA0;
+                }
+        }
+
+        etd->urb = urb;
+        etd->ep = urb_priv->ep;
+        etd->len = count;
+
+        if (usb_pipeint(pipe)) {
+                interval = urb->interval;
+                relpolpos = (readl(imx21->regs + USBH_FRMNUB) + 1) & 0xff;
+        }
+
+        /* Write ETD to device memory */
+        setup_etd_dword0(imx21, etd_num, urb, dir, maxpacket);
+
+        etd_writel(imx21, etd_num, 2,
+                (u32) interval << DW2_POLINTERV |
+                ((u32) relpolpos << DW2_RELPOLPOS) |
+                ((u32) dir << DW2_DIRPID) |
+                ((u32) bufround << DW2_BUFROUND) |
+                ((u32) datatoggle << DW2_DATATOG) |
+                ((u32) TD_NOTACCESSED << DW2_COMPCODE));
+
+        /* DMA will always transfer buffer size even if TOBYCNT in DWORD3
+           is smaller. Make sure we don't overrun the buffer!
+         */
+        if (count && count < maxpacket)
+                etd_buf_size = count;
+        else
+                etd_buf_size = maxpacket;
+
+        etd_writel(imx21, etd_num, 3,
+                ((u32) (etd_buf_size - 1) << DW3_BUFSIZE) | (u32) count);
+
+        if (!count)
+                etd->dma_handle = 0;
+
+        /* allocate x and y buffer space at once */
+        etd->dmem_size = (count > maxpacket) ? maxpacket * 2 : maxpacket;
+        dmem_offset = alloc_dmem(imx21, etd->dmem_size, urb_priv->ep);
+        if (dmem_offset < 0) {
+                /* Setup everything we can in HW and update when we get DMEM */
+                etd_writel(imx21, etd_num, 1, (u32)maxpacket << 16);
+
+                dev_dbg(imx21->dev, "Queuing etd %d for DMEM\n", etd_num);
+                debug_urb_queued_for_dmem(imx21, urb);
+                list_add_tail(&etd->queue, &imx21->queue_for_dmem);
+                return;
+        }
+
+        etd_writel(imx21, etd_num, 1,
+                (((u32) dmem_offset + (u32) maxpacket) << DW1_YBUFSRTAD) |
+                (u32) dmem_offset);
+
+        urb_priv->active = 1;
+
+        /* enable the ETD to kick off transfer */
+        dev_vdbg(imx21->dev, "Activating etd %d for %d bytes %s\n",
+                etd_num, count, dir != TD_DIR_IN ? "out" : "in");
+        activate_etd(imx21, etd_num, etd->dma_handle, dir);
+
+}
+
+static void nonisoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        struct etd_priv *etd = &imx21->etd[etd_num];
+        u32 etd_mask = 1 << etd_num;
+        struct urb_priv *urb_priv = urb->hcpriv;
+        int dir;
+        u16 xbufaddr;
+        int cc;
+        u32 bytes_xfrd;
+        int etd_done;
+
+        disactivate_etd(imx21, etd_num);
+
+        dir = (etd_readl(imx21, etd_num, 0) >> DW0_DIRECT) & 0x3;
+        xbufaddr = etd_readl(imx21, etd_num, 1) & 0xffff;
+        cc = (etd_readl(imx21, etd_num, 2) >> DW2_COMPCODE) & 0xf;
+        bytes_xfrd = etd->len - (etd_readl(imx21, etd_num, 3) & 0x1fffff);
+
+        /* save toggle carry */
+        usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
+                      usb_pipeout(urb->pipe),
+                      (etd_readl(imx21, etd_num, 0) >> DW0_TOGCRY) & 0x1);
+
+        if (dir == TD_DIR_IN) {
+                clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
+                clear_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
+        }
+        free_dmem(imx21, xbufaddr);
+
+        urb->error_count = 0;
+        if (!(urb->transfer_flags & URB_SHORT_NOT_OK)
+                        && (cc == TD_DATAUNDERRUN))
+                cc = TD_CC_NOERROR;
+
+        if (cc != 0)
+                dev_vdbg(imx21->dev, "cc is 0x%x\n", cc);
+
+        etd_done = (cc_to_error[cc] != 0);      /* stop if error */
+
+        switch (usb_pipetype(urb->pipe)) {
+        case PIPE_CONTROL:
+                switch (urb_priv->state) {
+                case US_CTRL_SETUP:
+                        if (urb->transfer_buffer_length > 0)
+                                urb_priv->state = US_CTRL_DATA;
+                        else
+                                urb_priv->state = US_CTRL_ACK;
+                        break;
+                case US_CTRL_DATA:
+                        urb->actual_length += bytes_xfrd;
+                        urb_priv->state = US_CTRL_ACK;
+                        break;
+                case US_CTRL_ACK:
+                        etd_done = 1;
+                        break;
+                default:
+                        dev_err(imx21->dev,
+                                "Invalid pipe state %d\n", urb_priv->state);
+                        etd_done = 1;
+                        break;
+                }
+                break;
+
+        case PIPE_BULK:
+                urb->actual_length += bytes_xfrd;
+                if ((urb_priv->state == US_BULK)
+                    && (urb->transfer_flags & URB_ZERO_PACKET)
+                    && urb->transfer_buffer_length > 0
+                    && ((urb->transfer_buffer_length %
+                         usb_maxpacket(urb->dev, urb->pipe,
+                                       usb_pipeout(urb->pipe))) == 0)) {
+                        /* need a 0-packet */
+                        urb_priv->state = US_BULK0;
+                } else {
+                        etd_done = 1;
+                }
+                break;
+
+        case PIPE_INTERRUPT:
+                urb->actual_length += bytes_xfrd;
+                etd_done = 1;
+                break;
+        }
+
+        if (!etd_done) {
+                dev_vdbg(imx21->dev, "next state=%d\n", urb_priv->state);
+                schedule_nonisoc_etd(imx21, urb);
+        } else {
+                struct usb_host_endpoint *ep = urb->ep;
+
+                urb_done(hcd, urb, cc_to_error[cc]);
+                etd->urb = NULL;
+
+                if (!list_empty(&ep->urb_list)) {
+                        urb = list_first_entry(&ep->urb_list,
+                                struct urb, urb_list);
+                        dev_vdbg(imx21->dev, "next URB %p\n", urb);
+                        schedule_nonisoc_etd(imx21, urb);
+                }
+        }
+}
+
+static struct ep_priv *alloc_ep(void)
+{
+        int i;
+        struct ep_priv *ep_priv;
+
+        ep_priv = kzalloc(sizeof(struct ep_priv), GFP_ATOMIC);
+        if (!ep_priv)
+                return NULL;
+
+        for (i = 0; i < NUM_ISO_ETDS; ++i)
+                ep_priv->etd[i] = -1;
+
+        return ep_priv;
+}
+
+static int imx21_hc_urb_enqueue(struct usb_hcd *hcd,
+                                struct urb *urb, gfp_t mem_flags)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        struct usb_host_endpoint *ep = urb->ep;
+        struct urb_priv *urb_priv;
+        struct ep_priv *ep_priv;
+        struct etd_priv *etd;
+        int ret;
+        unsigned long flags;
+        int new_ep = 0;
+
+        dev_vdbg(imx21->dev,
+                "enqueue urb=%p ep=%p len=%d "
+                "buffer=%p dma=%08X setupBuf=%p setupDma=%08X\n",
+                urb, ep,
+                urb->transfer_buffer_length,
+                urb->transfer_buffer, urb->transfer_dma,
+                urb->setup_packet, urb->setup_dma);
+
+        if (usb_pipeisoc(urb->pipe))
+                return imx21_hc_urb_enqueue_isoc(hcd, ep, urb, mem_flags);
+
+        urb_priv = kzalloc(sizeof(struct urb_priv), mem_flags);
+        if (!urb_priv)
+                return -ENOMEM;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        ep_priv = ep->hcpriv;
+        if (ep_priv == NULL) {
+                ep_priv = alloc_ep();
+                if (!ep_priv) {
+                        ret = -ENOMEM;
+                        goto failed_alloc_ep;
+                }
+                ep->hcpriv = ep_priv;
+                ep_priv->ep = ep;
+                new_ep = 1;
+        }
+
+        ret = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (ret)
+                goto failed_link;
+
+        urb->status = -EINPROGRESS;
+        urb->actual_length = 0;
+        urb->error_count = 0;
+        urb->hcpriv = urb_priv;
+        urb_priv->ep = ep;
+
+        switch (usb_pipetype(urb->pipe)) {
+        case PIPE_CONTROL:
+                urb_priv->state = US_CTRL_SETUP;
+                break;
+        case PIPE_BULK:
+                urb_priv->state = US_BULK;
+                break;
+        }
+
+        debug_urb_submitted(imx21, urb);
+        if (ep_priv->etd[0] < 0) {
+                if (ep_priv->waiting_etd) {
+                        dev_dbg(imx21->dev,
+                                "no ETD available already queued %p\n",
+                                ep_priv);
+                        debug_urb_queued_for_etd(imx21, urb);
+                        goto out;
+                }
+                ep_priv->etd[0] = alloc_etd(imx21);
+                if (ep_priv->etd[0] < 0) {
+                        dev_dbg(imx21->dev,
+                                "no ETD available queueing %p\n", ep_priv);
+                        debug_urb_queued_for_etd(imx21, urb);
+                        list_add_tail(&ep_priv->queue, &imx21->queue_for_etd);
+                        ep_priv->waiting_etd = 1;
+                        goto out;
+                }
+        }
+
+        /* Schedule if no URB already active for this endpoint */
+        etd = &imx21->etd[ep_priv->etd[0]];
+        if (etd->urb == NULL) {
+                DEBUG_LOG_FRAME(imx21, etd, last_req);
+                schedule_nonisoc_etd(imx21, urb);
+        }
+
+out:
+        spin_unlock_irqrestore(&imx21->lock, flags);
+        return 0;
+
+failed_link:
+failed_alloc_ep:
+        spin_unlock_irqrestore(&imx21->lock, flags);
+        kfree(urb_priv);
+        return ret;
+}
+
+static int imx21_hc_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
+                                int status)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        unsigned long flags;
+        struct usb_host_endpoint *ep;
+        struct ep_priv *ep_priv;
+        struct urb_priv *urb_priv = urb->hcpriv;
+        int ret = -EINVAL;
+
+        dev_vdbg(imx21->dev, "dequeue urb=%p iso=%d status=%d\n",
+                urb, usb_pipeisoc(urb->pipe), status);
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        ret = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (ret)
+                goto fail;
+        ep = urb_priv->ep;
+        ep_priv = ep->hcpriv;
+
+        debug_urb_unlinked(imx21, urb);
+
+        if (usb_pipeisoc(urb->pipe)) {
+                dequeue_isoc_urb(imx21, urb, ep_priv);
+                schedule_isoc_etds(hcd, ep);
+        } else if (urb_priv->active) {
+                int etd_num = ep_priv->etd[0];
+                if (etd_num != -1) {
+                        disactivate_etd(imx21, etd_num);
+                        free_dmem(imx21, etd_readl(imx21, etd_num, 1) & 0xffff);
+                        imx21->etd[etd_num].urb = NULL;
+                }
+        }
+
+        urb_done(hcd, urb, status);
+
+        spin_unlock_irqrestore(&imx21->lock, flags);
+        return 0;
+
+fail:
+        spin_unlock_irqrestore(&imx21->lock, flags);
+        return ret;
+}
+
+/* =========================================== */
+/* Interrupt dispatch                           */
+/* =========================================== */
+
+static void process_etds(struct usb_hcd *hcd, struct imx21 *imx21, int sof)
+{
+        int etd_num;
+        int enable_sof_int = 0;
+        unsigned long flags;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        for (etd_num = 0; etd_num < USB_NUM_ETD; etd_num++) {
+                u32 etd_mask = 1 << etd_num;
+                u32 enabled = readl(imx21->regs + USBH_ETDENSET) & etd_mask;
+                u32 done = readl(imx21->regs + USBH_ETDDONESTAT) & etd_mask;
+                struct etd_priv *etd = &imx21->etd[etd_num];
+
+
+                if (done) {
+                        DEBUG_LOG_FRAME(imx21, etd, last_int);
+                } else {
+/*
+ * Kludge warning!
+ *
+ * When multiple transfers are using the bus we sometimes get into a state
+ * where the transfer has completed (the CC field of the ETD is != 0x0F),
+ * the ETD has self disabled but the ETDDONESTAT flag is not set
+ * (and hence no interrupt occurs).
+ * This causes the transfer in question to hang.
+ * The kludge below checks for this condition at each SOF and processes any
+ * blocked ETDs (after an arbitary 10 frame wait)
+ *
+ * With a single active transfer the usbtest test suite will run for days
+ * without the kludge.
+ * With other bus activity (eg mass storage) even just test1 will hang without
+ * the kludge.
+ */
+                        u32 dword0;
+                        int cc;
+
+                        if (etd->active_count && !enabled) /* suspicious... */
+                                enable_sof_int = 1;
+
+                        if (!sof || enabled || !etd->active_count)
+                                continue;
+
+                        cc = etd_readl(imx21, etd_num, 2) >> DW2_COMPCODE;
+                        if (cc == TD_NOTACCESSED)
+                                continue;
+
+                        if (++etd->active_count < 10)
+                                continue;
+
+                        dword0 = etd_readl(imx21, etd_num, 0);
+                        dev_dbg(imx21->dev,
+                                "unblock ETD %d dev=0x%X ep=0x%X cc=0x%02X!\n",
+                                etd_num, dword0 & 0x7F,
+                                (dword0 >> DW0_ENDPNT) & 0x0F,
+                                cc);
+
+#ifdef DEBUG
+                        dev_dbg(imx21->dev,
+                                "frame: act=%d disact=%d"
+                                " int=%d req=%d cur=%d\n",
+                                etd->activated_frame,
+                                etd->disactivated_frame,
+                                etd->last_int_frame,
+                                etd->last_req_frame,
+                                readl(imx21->regs + USBH_FRMNUB));
+                        imx21->debug_unblocks++;
+#endif
+                        etd->active_count = 0;
+/* End of kludge */
+                }
+
+                if (etd->ep == NULL || etd->urb == NULL) {
+                        dev_dbg(imx21->dev,
+                                "Interrupt for unexpected etd %d"
+                                " ep=%p urb=%p\n",
+                                etd_num, etd->ep, etd->urb);
+                        disactivate_etd(imx21, etd_num);
+                        continue;
+                }
+
+                if (usb_pipeisoc(etd->urb->pipe))
+                        isoc_etd_done(hcd, etd->urb, etd_num);
+                else
+                        nonisoc_etd_done(hcd, etd->urb, etd_num);
+        }
+
+        /* only enable SOF interrupt if it may be needed for the kludge */
+        if (enable_sof_int)
+                set_register_bits(imx21, USBH_SYSIEN, USBH_SYSIEN_SOFINT);
+        else
+                clear_register_bits(imx21, USBH_SYSIEN, USBH_SYSIEN_SOFINT);
+
+
+        spin_unlock_irqrestore(&imx21->lock, flags);
+}
+
+static irqreturn_t imx21_irq(struct usb_hcd *hcd)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        u32 ints = readl(imx21->regs + USBH_SYSISR);
+
+        if (ints & USBH_SYSIEN_HERRINT)
+                dev_dbg(imx21->dev, "Scheduling error\n");
+
+        if (ints & USBH_SYSIEN_SORINT)
+                dev_dbg(imx21->dev, "Scheduling overrun\n");
+
+        if (ints & (USBH_SYSISR_DONEINT | USBH_SYSISR_SOFINT))
+                process_etds(hcd, imx21, ints & USBH_SYSISR_SOFINT);
+
+        writel(ints, imx21->regs + USBH_SYSISR);
+        return IRQ_HANDLED;
+}
+
+static void imx21_hc_endpoint_disable(struct usb_hcd *hcd,
+                                      struct usb_host_endpoint *ep)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        unsigned long flags;
+        struct ep_priv *ep_priv;
+        int i;
+
+        if (ep == NULL)
+                return;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+        ep_priv = ep->hcpriv;
+        dev_vdbg(imx21->dev, "disable ep=%p, ep->hcpriv=%p\n", ep, ep_priv);
+
+        if (!list_empty(&ep->urb_list))
+                dev_dbg(imx21->dev, "ep's URB list is not empty\n");
+
+        if (ep_priv != NULL) {
+                for (i = 0; i < NUM_ISO_ETDS; i++) {
+                        if (ep_priv->etd[i] > -1)
+                                dev_dbg(imx21->dev, "free etd %d for disable\n",
+                                        ep_priv->etd[i]);
+
+                        free_etd(imx21, ep_priv->etd[i]);
+                }
+                kfree(ep_priv);
+                ep->hcpriv = NULL;
+        }
+
+        for (i = 0; i < USB_NUM_ETD; i++) {
+                if (imx21->etd[i].alloc && imx21->etd[i].ep == ep) {
+                        dev_err(imx21->dev,
+                                "Active etd %d for disabled ep=%p!\n", i, ep);
+                        free_etd(imx21, i);
+                }
+        }
+        free_epdmem(imx21, ep);
+        spin_unlock_irqrestore(&imx21->lock, flags);
+}
+
+/* =========================================== */
+/* Hub handling                                 */
+/* =========================================== */
+
+static int get_hub_descriptor(struct usb_hcd *hcd,
+                              struct usb_hub_descriptor *desc)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        desc->bDescriptorType = 0x29;   /* HUB descriptor */
+        desc->bHubContrCurrent = 0;
+
+        desc->bNbrPorts = readl(imx21->regs + USBH_ROOTHUBA)
+                & USBH_ROOTHUBA_NDNSTMPRT_MASK;
+        desc->bDescLength = 9;
+        desc->bPwrOn2PwrGood = 0;
+        desc->wHubCharacteristics = (__force __u16) cpu_to_le16(
+                0x0002 |        /* No power switching */
+                0x0010 |        /* No over current protection */
+                0);
+
+        desc->bitmap[0] = 1 << 1;
+        desc->bitmap[1] = ~0;
+        return 0;
+}
+
+static int imx21_hc_hub_status_data(struct usb_hcd *hcd, char *buf)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        int ports;
+        int changed = 0;
+        int i;
+        unsigned long flags;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+        ports = readl(imx21->regs + USBH_ROOTHUBA)
+                & USBH_ROOTHUBA_NDNSTMPRT_MASK;
+        if (ports > 7) {
+                ports = 7;
+                dev_err(imx21->dev, "ports %d > 7\n", ports);
+        }
+        for (i = 0; i < ports; i++) {
+                if (readl(imx21->regs + USBH_PORTSTAT(i)) &
+                        (USBH_PORTSTAT_CONNECTSC |
+                        USBH_PORTSTAT_PRTENBLSC |
+                        USBH_PORTSTAT_PRTSTATSC |
+                        USBH_PORTSTAT_OVRCURIC |
+                        USBH_PORTSTAT_PRTRSTSC)) {
+
+                        changed = 1;
+                        buf[0] |= 1 << (i + 1);
+                }
+        }
+        spin_unlock_irqrestore(&imx21->lock, flags);
+
+        if (changed)
+                dev_info(imx21->dev, "Hub status changed\n");
+        return changed;
+}
+
+static int imx21_hc_hub_control(struct usb_hcd *hcd,
+                                u16 typeReq,
+                                u16 wValue, u16 wIndex, char *buf, u16 wLength)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        int rc = 0;
+        u32 status_write = 0;
+
+        switch (typeReq) {
+        case ClearHubFeature:
+                dev_dbg(imx21->dev, "ClearHubFeature\n");
+                switch (wValue) {
+                case C_HUB_OVER_CURRENT:
+                        dev_dbg(imx21->dev, "    OVER_CURRENT\n");
+                        break;
+                case C_HUB_LOCAL_POWER:
+                        dev_dbg(imx21->dev, "    LOCAL_POWER\n");
+                        break;
+                default:
+                        dev_dbg(imx21->dev, "    unknown\n");
+                        rc = -EINVAL;
+                        break;
+                }
+                break;
+
+        case ClearPortFeature:
+                dev_dbg(imx21->dev, "ClearPortFeature\n");
+                switch (wValue) {
+                case USB_PORT_FEAT_ENABLE:
+                        dev_dbg(imx21->dev, "    ENABLE\n");
+                        status_write = USBH_PORTSTAT_CURCONST;
+                        break;
+                case USB_PORT_FEAT_SUSPEND:
+                        dev_dbg(imx21->dev, "    SUSPEND\n");
+                        status_write = USBH_PORTSTAT_PRTOVRCURI;
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        dev_dbg(imx21->dev, "    POWER\n");
+                        status_write = USBH_PORTSTAT_LSDEVCON;
+                        break;
+                case USB_PORT_FEAT_C_ENABLE:
+                        dev_dbg(imx21->dev, "    C_ENABLE\n");
+                        status_write = USBH_PORTSTAT_PRTENBLSC;
+                        break;
+                case USB_PORT_FEAT_C_SUSPEND:
+                        dev_dbg(imx21->dev, "    C_SUSPEND\n");
+                        status_write = USBH_PORTSTAT_PRTSTATSC;
+                        break;
+                case USB_PORT_FEAT_C_CONNECTION:
+                        dev_dbg(imx21->dev, "    C_CONNECTION\n");
+                        status_write = USBH_PORTSTAT_CONNECTSC;
+                        break;
+                case USB_PORT_FEAT_C_OVER_CURRENT:
+                        dev_dbg(imx21->dev, "    C_OVER_CURRENT\n");
+                        status_write = USBH_PORTSTAT_OVRCURIC;
+                        break;
+                case USB_PORT_FEAT_C_RESET:
+                        dev_dbg(imx21->dev, "    C_RESET\n");
+                        status_write = USBH_PORTSTAT_PRTRSTSC;
+                        break;
+                default:
+                        dev_dbg(imx21->dev, "    unknown\n");
+                        rc = -EINVAL;
+                        break;
+                }
+
+                break;
+
+        case GetHubDescriptor:
+                dev_dbg(imx21->dev, "GetHubDescriptor\n");
+                rc = get_hub_descriptor(hcd, (void *)buf);
+                break;
+
+        case GetHubStatus:
+                dev_dbg(imx21->dev, "  GetHubStatus\n");
+                *(__le32 *) buf = 0;
+                break;
+
+        case GetPortStatus:
+                dev_dbg(imx21->dev, "GetPortStatus: port: %d, 0x%x\n",
+                    wIndex, USBH_PORTSTAT(wIndex - 1));
+                *(__le32 *) buf = readl(imx21->regs +
+                        USBH_PORTSTAT(wIndex - 1));
+                break;
+
+        case SetHubFeature:
+                dev_dbg(imx21->dev, "SetHubFeature\n");
+                switch (wValue) {
+                case C_HUB_OVER_CURRENT:
+                        dev_dbg(imx21->dev, "    OVER_CURRENT\n");
+                        break;
+
+                case C_HUB_LOCAL_POWER:
+                        dev_dbg(imx21->dev, "    LOCAL_POWER\n");
+                        break;
+                default:
+                        dev_dbg(imx21->dev, "    unknown\n");
+                        rc = -EINVAL;
+                        break;
+                }
+
+                break;
+
+        case SetPortFeature:
+                dev_dbg(imx21->dev, "SetPortFeature\n");
+                switch (wValue) {
+                case USB_PORT_FEAT_SUSPEND:
+                        dev_dbg(imx21->dev, "    SUSPEND\n");
+                        status_write = USBH_PORTSTAT_PRTSUSPST;
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        dev_dbg(imx21->dev, "    POWER\n");
+                        status_write = USBH_PORTSTAT_PRTPWRST;
+                        break;
+                case USB_PORT_FEAT_RESET:
+                        dev_dbg(imx21->dev, "    RESET\n");
+                        status_write = USBH_PORTSTAT_PRTRSTST;
+                        break;
+                default:
+                        dev_dbg(imx21->dev, "    unknown\n");
+                        rc = -EINVAL;
+                        break;
+                }
+                break;
+
+        default:
+                dev_dbg(imx21->dev, "  unknown\n");
+                rc = -EINVAL;
+                break;
+        }
+
+        if (status_write)
+                writel(status_write, imx21->regs + USBH_PORTSTAT(wIndex - 1));
+        return rc;
+}
+
+/* =========================================== */
+/* Host controller management                   */
+/* =========================================== */
+
+static int imx21_hc_reset(struct usb_hcd *hcd)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        unsigned long timeout;
+        unsigned long flags;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        /* Reset the Host controler modules */
+        writel(USBOTG_RST_RSTCTRL | USBOTG_RST_RSTRH |
+                USBOTG_RST_RSTHSIE | USBOTG_RST_RSTHC,
+                imx21->regs + USBOTG_RST_CTRL);
+
+        /* Wait for reset to finish */
+        timeout = jiffies + HZ;
+        while (readl(imx21->regs + USBOTG_RST_CTRL) != 0) {
+                if (time_after(jiffies, timeout)) {
+                        spin_unlock_irqrestore(&imx21->lock, flags);
+                        dev_err(imx21->dev, "timeout waiting for reset\n");
+                        return -ETIMEDOUT;
+                }
+                spin_unlock_irq(&imx21->lock);
+                schedule_timeout(1);
+                spin_lock_irq(&imx21->lock);
+        }
+        spin_unlock_irqrestore(&imx21->lock, flags);
+        return 0;
+}
+
+static int __devinit imx21_hc_start(struct usb_hcd *hcd)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        unsigned long flags;
+        int i, j;
+        u32 hw_mode = USBOTG_HWMODE_CRECFG_HOST;
+        u32 usb_control = 0;
+
+        hw_mode |= ((imx21->pdata->host_xcvr << USBOTG_HWMODE_HOSTXCVR_SHIFT) &
+                        USBOTG_HWMODE_HOSTXCVR_MASK);
+        hw_mode |= ((imx21->pdata->otg_xcvr << USBOTG_HWMODE_OTGXCVR_SHIFT) &
+                        USBOTG_HWMODE_OTGXCVR_MASK);
+
+        if (imx21->pdata->host1_txenoe)
+                usb_control |= USBCTRL_HOST1_TXEN_OE;
+
+        if (!imx21->pdata->host1_xcverless)
+                usb_control |= USBCTRL_HOST1_BYP_TLL;
+
+        if (imx21->pdata->otg_ext_xcvr)
+                usb_control |= USBCTRL_OTC_RCV_RXDP;
+
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        writel((USBOTG_CLK_CTRL_HST | USBOTG_CLK_CTRL_MAIN),
+                imx21->regs + USBOTG_CLK_CTRL);
+        writel(hw_mode, imx21->regs + USBOTG_HWMODE);
+        writel(usb_control, imx21->regs + USBCTRL);
+        writel(USB_MISCCONTROL_SKPRTRY  | USB_MISCCONTROL_ARBMODE,
+                imx21->regs + USB_MISCCONTROL);
+
+        /* Clear the ETDs */
+        for (i = 0; i < USB_NUM_ETD; i++)
+                for (j = 0; j < 4; j++)
+                        etd_writel(imx21, i, j, 0);
+
+        /* Take the HC out of reset */
+        writel(USBH_HOST_CTRL_HCUSBSTE_OPERATIONAL | USBH_HOST_CTRL_CTLBLKSR_1,
+                imx21->regs + USBH_HOST_CTRL);
+
+        /* Enable ports */
+        if (imx21->pdata->enable_otg_host)
+                writel(USBH_PORTSTAT_PRTPWRST | USBH_PORTSTAT_PRTENABST,
+                        imx21->regs + USBH_PORTSTAT(0));
+
+        if (imx21->pdata->enable_host1)
+                writel(USBH_PORTSTAT_PRTPWRST | USBH_PORTSTAT_PRTENABST,
+                        imx21->regs + USBH_PORTSTAT(1));
+
+        if (imx21->pdata->enable_host2)
+                writel(USBH_PORTSTAT_PRTPWRST | USBH_PORTSTAT_PRTENABST,
+                        imx21->regs + USBH_PORTSTAT(2));
+
+
+        hcd->state = HC_STATE_RUNNING;
+
+        /* Enable host controller interrupts */
+        set_register_bits(imx21, USBH_SYSIEN,
+                USBH_SYSIEN_HERRINT |
+                USBH_SYSIEN_DONEINT | USBH_SYSIEN_SORINT);
+        set_register_bits(imx21, USBOTG_CINT_STEN, USBOTG_HCINT);
+
+        spin_unlock_irqrestore(&imx21->lock, flags);
+
+        return 0;
+}
+
+static void imx21_hc_stop(struct usb_hcd *hcd)
+{
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        unsigned long flags;
+
+        spin_lock_irqsave(&imx21->lock, flags);
+
+        writel(0, imx21->regs + USBH_SYSIEN);
+        clear_register_bits(imx21, USBOTG_CINT_STEN, USBOTG_HCINT);
+        clear_register_bits(imx21, USBOTG_CLK_CTRL_HST | USBOTG_CLK_CTRL_MAIN,
+                                        USBOTG_CLK_CTRL);
+        spin_unlock_irqrestore(&imx21->lock, flags);
+}
+
+/* =========================================== */
+/* Driver glue                                  */
+/* =========================================== */
+
+static struct hc_driver imx21_hc_driver = {
+        .description = hcd_name,
+        .product_desc = "IMX21 USB Host Controller",
+        .hcd_priv_size = sizeof(struct imx21),
+
+        .flags = HCD_USB11,
+        .irq = imx21_irq,
+
+        .reset = imx21_hc_reset,
+        .start = imx21_hc_start,
+        .stop = imx21_hc_stop,
+
+        /* I/O requests */
+        .urb_enqueue = imx21_hc_urb_enqueue,
+        .urb_dequeue = imx21_hc_urb_dequeue,
+        .endpoint_disable = imx21_hc_endpoint_disable,
+
+        /* scheduling support */
+        .get_frame_number = imx21_hc_get_frame,
+
+        /* Root hub support */
+        .hub_status_data = imx21_hc_hub_status_data,
+        .hub_control = imx21_hc_hub_control,
+
+};
+
+static struct mx21_usbh_platform_data default_pdata = {
+        .host_xcvr = MX21_USBXCVR_TXDIF_RXDIF,
+        .otg_xcvr = MX21_USBXCVR_TXDIF_RXDIF,
+        .enable_host1 = 1,
+        .enable_host2 = 1,
+        .enable_otg_host = 1,
+
+};
+
+static int imx21_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct imx21 *imx21 = hcd_to_imx21(hcd);
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        remove_debug_files(imx21);
+        usb_remove_hcd(hcd);
+
+        if (res != NULL) {
+                clk_disable(imx21->clk);
+                clk_put(imx21->clk);
+                iounmap(imx21->regs);
+                release_mem_region(res->start, resource_size(res));
+        }
+
+        kfree(hcd);
+        return 0;
+}
+
+
+static int imx21_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct imx21 *imx21;
+        struct resource *res;
+        int ret;
+        int irq;
+
+        printk(KERN_INFO "%s\n", imx21_hc_driver.product_desc);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return -ENXIO;
+
+        hcd = usb_create_hcd(&imx21_hc_driver,
+                &pdev->dev, dev_name(&pdev->dev));
+        if (hcd == NULL) {
+                dev_err(&pdev->dev, "Cannot create hcd (%s)\n",
+                    dev_name(&pdev->dev));
+                return -ENOMEM;
+        }
+
+        imx21 = hcd_to_imx21(hcd);
+        imx21->dev = &pdev->dev;
+        imx21->pdata = pdev->dev.platform_data;
+        if (!imx21->pdata)
+                imx21->pdata = &default_pdata;
+
+        spin_lock_init(&imx21->lock);
+        INIT_LIST_HEAD(&imx21->dmem_list);
+        INIT_LIST_HEAD(&imx21->queue_for_etd);
+        INIT_LIST_HEAD(&imx21->queue_for_dmem);
+        create_debug_files(imx21);
+
+        res = request_mem_region(res->start, resource_size(res), hcd_name);
+        if (!res) {
+                ret = -EBUSY;
+                goto failed_request_mem;
+        }
+
+        imx21->regs = ioremap(res->start, resource_size(res));
+        if (imx21->regs == NULL) {
+                dev_err(imx21->dev, "Cannot map registers\n");
+                ret = -ENOMEM;
+                goto failed_ioremap;
+        }
+
+        /* Enable clocks source */
+        imx21->clk = clk_get(imx21->dev, NULL);
+        if (IS_ERR(imx21->clk)) {
+                dev_err(imx21->dev, "no clock found\n");
+                ret = PTR_ERR(imx21->clk);
+                goto failed_clock_get;
+        }
+
+        ret = clk_set_rate(imx21->clk, clk_round_rate(imx21->clk, 48000000));
+        if (ret)
+                goto failed_clock_set;
+        ret = clk_enable(imx21->clk);
+        if (ret)
+                goto failed_clock_enable;
+
+        dev_info(imx21->dev, "Hardware HC revision: 0x%02X\n",
+                (readl(imx21->regs + USBOTG_HWMODE) >> 16) & 0xFF);
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        if (ret != 0) {
+                dev_err(imx21->dev, "usb_add_hcd() returned %d\n", ret);
+                goto failed_add_hcd;
+        }
+
+        return 0;
+
+failed_add_hcd:
+        clk_disable(imx21->clk);
+failed_clock_enable:
+failed_clock_set:
+        clk_put(imx21->clk);
+failed_clock_get:
+        iounmap(imx21->regs);
+failed_ioremap:
+        release_mem_region(res->start, res->end - res->start);
+failed_request_mem:
+        remove_debug_files(imx21);
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static struct platform_driver imx21_hcd_driver = {
+        .driver = {
+                   .name = (char *)hcd_name,
+                   },
+        .probe = imx21_probe,
+        .remove = imx21_remove,
+        .suspend = NULL,
+        .resume = NULL,
+};
+
+static int __init imx21_hcd_init(void)
+{
+        return platform_driver_register(&imx21_hcd_driver);
+}
+
+static void __exit imx21_hcd_cleanup(void)
+{
+        platform_driver_unregister(&imx21_hcd_driver);
+}
+
+module_init(imx21_hcd_init);
+module_exit(imx21_hcd_cleanup);
+
+MODULE_DESCRIPTION("i.MX21 USB Host controller");
+MODULE_AUTHOR("Martin Fuzzey");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:imx21-hcd");
diff --git a/drivers/usb/host/imx21-hcd.h b/drivers/usb/host/imx21-hcd.h
new file mode 100644
index 000000000000..1b0d913780a5
--- /dev/null
+++ b/drivers/usb/host/imx21-hcd.h
@@ -0,0 +1,436 @@
+/*
+ * Macros and prototypes for i.MX21
+ *
+ * Copyright (C) 2006 Loping Dog Embedded Systems
+ * Copyright (C) 2009 Martin Fuzzey
+ * Originally written by Jay Monkman <jtm@lopingdog.com>
+ * Ported to 2.6.30, debugged and enhanced by Martin Fuzzey
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LINUX_IMX21_HCD_H__
+#define __LINUX_IMX21_HCD_H__
+
+#include <mach/mx21-usbhost.h>
+
+#define NUM_ISO_ETDS    2
+#define USB_NUM_ETD     32
+#define DMEM_SIZE       4096
+
+/* Register definitions */
+#define USBOTG_HWMODE           0x00
+#define USBOTG_HWMODE_ANASDBEN          (1 << 14)
+#define USBOTG_HWMODE_OTGXCVR_SHIFT     6
+#define USBOTG_HWMODE_OTGXCVR_MASK      (3 << 6)
+#define USBOTG_HWMODE_OTGXCVR_TD_RD     (0 << 6)
+#define USBOTG_HWMODE_OTGXCVR_TS_RD     (2 << 6)
+#define USBOTG_HWMODE_OTGXCVR_TD_RS     (1 << 6)
+#define USBOTG_HWMODE_OTGXCVR_TS_RS     (3 << 6)
+#define USBOTG_HWMODE_HOSTXCVR_SHIFT    4
+#define USBOTG_HWMODE_HOSTXCVR_MASK     (3 << 4)
+#define USBOTG_HWMODE_HOSTXCVR_TD_RD    (0 << 4)
+#define USBOTG_HWMODE_HOSTXCVR_TS_RD    (2 << 4)
+#define USBOTG_HWMODE_HOSTXCVR_TD_RS    (1 << 4)
+#define USBOTG_HWMODE_HOSTXCVR_TS_RS    (3 << 4)
+#define USBOTG_HWMODE_CRECFG_MASK       (3 << 0)
+#define USBOTG_HWMODE_CRECFG_HOST       (1 << 0)
+#define USBOTG_HWMODE_CRECFG_FUNC       (2 << 0)
+#define USBOTG_HWMODE_CRECFG_HNP        (3 << 0)
+
+#define USBOTG_CINT_STAT        0x04
+#define USBOTG_CINT_STEN        0x08
+#define USBOTG_ASHNPINT                 (1 << 5)
+#define USBOTG_ASFCINT                  (1 << 4)
+#define USBOTG_ASHCINT                  (1 << 3)
+#define USBOTG_SHNPINT                  (1 << 2)
+#define USBOTG_FCINT                    (1 << 1)
+#define USBOTG_HCINT                    (1 << 0)
+
+#define USBOTG_CLK_CTRL         0x0c
+#define USBOTG_CLK_CTRL_FUNC            (1 << 2)
+#define USBOTG_CLK_CTRL_HST             (1 << 1)
+#define USBOTG_CLK_CTRL_MAIN            (1 << 0)
+
+#define USBOTG_RST_CTRL         0x10
+#define USBOTG_RST_RSTI2C               (1 << 15)
+#define USBOTG_RST_RSTCTRL              (1 << 5)
+#define USBOTG_RST_RSTFC                (1 << 4)
+#define USBOTG_RST_RSTFSKE              (1 << 3)
+#define USBOTG_RST_RSTRH                (1 << 2)
+#define USBOTG_RST_RSTHSIE              (1 << 1)
+#define USBOTG_RST_RSTHC                (1 << 0)
+
+#define USBOTG_FRM_INTVL        0x14
+#define USBOTG_FRM_REMAIN       0x18
+#define USBOTG_HNP_CSR          0x1c
+#define USBOTG_HNP_ISR          0x2c
+#define USBOTG_HNP_IEN          0x30
+
+#define USBOTG_I2C_TXCVR_REG(x) (0x100 + (x))
+#define USBOTG_I2C_XCVR_DEVAD           0x118
+#define USBOTG_I2C_SEQ_OP_REG           0x119
+#define USBOTG_I2C_SEQ_RD_STARTAD       0x11a
+#define USBOTG_I2C_OP_CTRL_REG          0x11b
+#define USBOTG_I2C_SCLK_TO_SCK_HPER     0x11e
+#define USBOTG_I2C_MASTER_INT_REG       0x11f
+
+#define USBH_HOST_CTRL          0x80
+#define USBH_HOST_CTRL_HCRESET                  (1 << 31)
+#define USBH_HOST_CTRL_SCHDOVR(x)               ((x) << 16)
+#define USBH_HOST_CTRL_RMTWUEN                  (1 << 4)
+#define USBH_HOST_CTRL_HCUSBSTE_RESET           (0 << 2)
+#define USBH_HOST_CTRL_HCUSBSTE_RESUME          (1 << 2)
+#define USBH_HOST_CTRL_HCUSBSTE_OPERATIONAL     (2 << 2)
+#define USBH_HOST_CTRL_HCUSBSTE_SUSPEND (3 << 2)
+#define USBH_HOST_CTRL_CTLBLKSR_1               (0 << 0)
+#define USBH_HOST_CTRL_CTLBLKSR_2               (1 << 0)
+#define USBH_HOST_CTRL_CTLBLKSR_3               (2 << 0)
+#define USBH_HOST_CTRL_CTLBLKSR_4               (3 << 0)
+
+#define USBH_SYSISR             0x88
+#define USBH_SYSISR_PSCINT              (1 << 6)
+#define USBH_SYSISR_FMOFINT             (1 << 5)
+#define USBH_SYSISR_HERRINT             (1 << 4)
+#define USBH_SYSISR_RESDETINT           (1 << 3)
+#define USBH_SYSISR_SOFINT              (1 << 2)
+#define USBH_SYSISR_DONEINT             (1 << 1)
+#define USBH_SYSISR_SORINT              (1 << 0)
+
+#define USBH_SYSIEN             0x8c
+#define USBH_SYSIEN_PSCINT              (1 << 6)
+#define USBH_SYSIEN_FMOFINT             (1 << 5)
+#define USBH_SYSIEN_HERRINT             (1 << 4)
+#define USBH_SYSIEN_RESDETINT           (1 << 3)
+#define USBH_SYSIEN_SOFINT              (1 << 2)
+#define USBH_SYSIEN_DONEINT             (1 << 1)
+#define USBH_SYSIEN_SORINT              (1 << 0)
+
+#define USBH_XBUFSTAT           0x98
+#define USBH_YBUFSTAT           0x9c
+#define USBH_XYINTEN            0xa0
+#define USBH_XFILLSTAT          0xa8
+#define USBH_YFILLSTAT          0xac
+#define USBH_ETDENSET           0xc0
+#define USBH_ETDENCLR           0xc4
+#define USBH_IMMEDINT           0xcc
+#define USBH_ETDDONESTAT        0xd0
+#define USBH_ETDDONEEN          0xd4
+#define USBH_FRMNUB             0xe0
+#define USBH_LSTHRESH           0xe4
+
+#define USBH_ROOTHUBA           0xe8
+#define USBH_ROOTHUBA_PWRTOGOOD_MASK    (0xff)
+#define USBH_ROOTHUBA_PWRTOGOOD_SHIFT   (24)
+#define USBH_ROOTHUBA_NOOVRCURP (1 << 12)
+#define USBH_ROOTHUBA_OVRCURPM          (1 << 11)
+#define USBH_ROOTHUBA_DEVTYPE           (1 << 10)
+#define USBH_ROOTHUBA_PWRSWTMD          (1 << 9)
+#define USBH_ROOTHUBA_NOPWRSWT          (1 << 8)
+#define USBH_ROOTHUBA_NDNSTMPRT_MASK    (0xff)
+
+#define USBH_ROOTHUBB           0xec
+#define USBH_ROOTHUBB_PRTPWRCM(x)       (1 << ((x) + 16))
+#define USBH_ROOTHUBB_DEVREMOVE(x)      (1 << (x))
+
+#define USBH_ROOTSTAT           0xf0
+#define USBH_ROOTSTAT_CLRRMTWUE (1 << 31)
+#define USBH_ROOTSTAT_OVRCURCHG (1 << 17)
+#define USBH_ROOTSTAT_DEVCONWUE (1 << 15)
+#define USBH_ROOTSTAT_OVRCURI           (1 << 1)
+#define USBH_ROOTSTAT_LOCPWRS           (1 << 0)
+
+#define USBH_PORTSTAT(x)        (0xf4 + ((x) * 4))
+#define USBH_PORTSTAT_PRTRSTSC          (1 << 20)
+#define USBH_PORTSTAT_OVRCURIC          (1 << 19)
+#define USBH_PORTSTAT_PRTSTATSC (1 << 18)
+#define USBH_PORTSTAT_PRTENBLSC (1 << 17)
+#define USBH_PORTSTAT_CONNECTSC (1 << 16)
+#define USBH_PORTSTAT_LSDEVCON          (1 << 9)
+#define USBH_PORTSTAT_PRTPWRST          (1 << 8)
+#define USBH_PORTSTAT_PRTRSTST          (1 << 4)
+#define USBH_PORTSTAT_PRTOVRCURI        (1 << 3)
+#define USBH_PORTSTAT_PRTSUSPST (1 << 2)
+#define USBH_PORTSTAT_PRTENABST (1 << 1)
+#define USBH_PORTSTAT_CURCONST          (1 << 0)
+
+#define USB_DMAREV              0x800
+#define USB_DMAINTSTAT          0x804
+#define USB_DMAINTSTAT_EPERR            (1 << 1)
+#define USB_DMAINTSTAT_ETDERR           (1 << 0)
+
+#define USB_DMAINTEN            0x808
+#define USB_DMAINTEN_EPERRINTEN (1 << 1)
+#define USB_DMAINTEN_ETDERRINTEN        (1 << 0)
+
+#define USB_ETDDMAERSTAT        0x80c
+#define USB_EPDMAERSTAT         0x810
+#define USB_ETDDMAEN            0x820
+#define USB_EPDMAEN             0x824
+#define USB_ETDDMAXTEN          0x828
+#define USB_EPDMAXTEN           0x82c
+#define USB_ETDDMAENXYT         0x830
+#define USB_EPDMAENXYT          0x834
+#define USB_ETDDMABST4EN        0x838
+#define USB_EPDMABST4EN         0x83c
+
+#define USB_MISCCONTROL         0x840
+#define USB_MISCCONTROL_ISOPREVFRM      (1 << 3)
+#define USB_MISCCONTROL_SKPRTRY (1 << 2)
+#define USB_MISCCONTROL_ARBMODE (1 << 1)
+#define USB_MISCCONTROL_FILTCC          (1 << 0)
+
+#define USB_ETDDMACHANLCLR      0x848
+#define USB_EPDMACHANLCLR       0x84c
+#define USB_ETDSMSA(x)          (0x900 + ((x) * 4))
+#define USB_EPSMSA(x)           (0x980 + ((x) * 4))
+#define USB_ETDDMABUFPTR(x)     (0xa00 + ((x) * 4))
+#define USB_EPDMABUFPTR(x)      (0xa80 + ((x) * 4))
+
+#define USB_ETD_DWORD(x, w)     (0x200 + ((x) * 16) + ((w) * 4))
+#define DW0_ADDRESS     0
+#define DW0_ENDPNT      7
+#define DW0_DIRECT      11
+#define DW0_SPEED       13
+#define DW0_FORMAT      14
+#define DW0_MAXPKTSIZ   16
+#define DW0_HALTED      27
+#define DW0_TOGCRY      28
+#define DW0_SNDNAK      30
+
+#define DW1_XBUFSRTAD   0
+#define DW1_YBUFSRTAD   16
+
+#define DW2_RTRYDELAY   0
+#define DW2_POLINTERV   0
+#define DW2_STARTFRM    0
+#define DW2_RELPOLPOS   8
+#define DW2_DIRPID      16
+#define DW2_BUFROUND    18
+#define DW2_DELAYINT    19
+#define DW2_DATATOG     22
+#define DW2_ERRORCNT    24
+#define DW2_COMPCODE    28
+
+#define DW3_TOTBYECNT   0
+#define DW3_PKTLEN0     0
+#define DW3_COMPCODE0   12
+#define DW3_PKTLEN1     16
+#define DW3_BUFSIZE     21
+#define DW3_COMPCODE1   28
+
+#define USBCTRL                 0x600
+#define USBCTRL_I2C_WU_INT_STAT (1 << 27)
+#define USBCTRL_OTG_WU_INT_STAT (1 << 26)
+#define USBCTRL_HOST_WU_INT_STAT        (1 << 25)
+#define USBCTRL_FNT_WU_INT_STAT (1 << 24)
+#define USBCTRL_I2C_WU_INT_EN           (1 << 19)
+#define USBCTRL_OTG_WU_INT_EN           (1 << 18)
+#define USBCTRL_HOST_WU_INT_EN          (1 << 17)
+#define USBCTRL_FNT_WU_INT_EN           (1 << 16)
+#define USBCTRL_OTC_RCV_RXDP            (1 << 13)
+#define USBCTRL_HOST1_BYP_TLL           (1 << 12)
+#define USBCTRL_OTG_BYP_VAL(x)          ((x) << 10)
+#define USBCTRL_HOST1_BYP_VAL(x)        ((x) << 8)
+#define USBCTRL_OTG_PWR_MASK            (1 << 6)
+#define USBCTRL_HOST1_PWR_MASK          (1 << 5)
+#define USBCTRL_HOST2_PWR_MASK          (1 << 4)
+#define USBCTRL_USB_BYP                 (1 << 2)
+#define USBCTRL_HOST1_TXEN_OE           (1 << 1)
+
+
+/* Values in TD blocks */
+#define TD_DIR_SETUP        0
+#define TD_DIR_OUT          1
+#define TD_DIR_IN           2
+#define TD_FORMAT_CONTROL   0
+#define TD_FORMAT_ISO       1
+#define TD_FORMAT_BULK      2
+#define TD_FORMAT_INT       3
+#define TD_TOGGLE_CARRY     0
+#define TD_TOGGLE_DATA0     2
+#define TD_TOGGLE_DATA1     3
+
+/* control transfer states */
+#define US_CTRL_SETUP   2
+#define US_CTRL_DATA    1
+#define US_CTRL_ACK     0
+
+/* bulk transfer main state and 0-length packet */
+#define US_BULK         1
+#define US_BULK0        0
+
+/*ETD format description*/
+#define IMX_FMT_CTRL   0x0
+#define IMX_FMT_ISO    0x1
+#define IMX_FMT_BULK   0x2
+#define IMX_FMT_INT    0x3
+
+static char fmt_urb_to_etd[4] = {
+/*PIPE_ISOCHRONOUS*/ IMX_FMT_ISO,
+/*PIPE_INTERRUPT*/ IMX_FMT_INT,
+/*PIPE_CONTROL*/ IMX_FMT_CTRL,
+/*PIPE_BULK*/ IMX_FMT_BULK
+};
+
+/* condition (error) CC codes and mapping (OHCI like) */
+
+#define TD_CC_NOERROR           0x00
+#define TD_CC_CRC               0x01
+#define TD_CC_BITSTUFFING       0x02
+#define TD_CC_DATATOGGLEM       0x03
+#define TD_CC_STALL             0x04
+#define TD_DEVNOTRESP           0x05
+#define TD_PIDCHECKFAIL         0x06
+/*#define TD_UNEXPECTEDPID      0x07 - reserved, not active on MX2*/
+#define TD_DATAOVERRUN          0x08
+#define TD_DATAUNDERRUN         0x09
+#define TD_BUFFEROVERRUN        0x0C
+#define TD_BUFFERUNDERRUN       0x0D
+#define TD_SCHEDULEOVERRUN      0x0E
+#define TD_NOTACCESSED          0x0F
+
+static const int cc_to_error[16] = {
+        /* No  Error  */ 0,
+        /* CRC Error  */ -EILSEQ,
+        /* Bit Stuff  */ -EPROTO,
+        /* Data Togg  */ -EILSEQ,
+        /* Stall      */ -EPIPE,
+        /* DevNotResp */ -ETIMEDOUT,
+        /* PIDCheck   */ -EPROTO,
+        /* UnExpPID   */ -EPROTO,
+        /* DataOver   */ -EOVERFLOW,
+        /* DataUnder  */ -EREMOTEIO,
+        /* (for hw)   */ -EIO,
+        /* (for hw)   */ -EIO,
+        /* BufferOver */ -ECOMM,
+        /* BuffUnder  */ -ENOSR,
+        /* (for HCD)  */ -ENOSPC,
+        /* (for HCD)  */ -EALREADY
+};
+
+/* HCD data associated with a usb core URB */
+struct urb_priv {
+        struct urb *urb;
+        struct usb_host_endpoint *ep;
+        int active;
+        int state;
+        struct td *isoc_td;
+        int isoc_remaining;
+        int isoc_status;
+};
+
+/* HCD data associated with a usb core endpoint */
+struct ep_priv {
+        struct usb_host_endpoint *ep;
+        struct list_head td_list;
+        struct list_head queue;
+        int etd[NUM_ISO_ETDS];
+        int waiting_etd;
+};
+
+/* isoc packet */
+struct td {
+        struct list_head list;
+        struct urb *urb;
+        struct usb_host_endpoint *ep;
+        dma_addr_t data;
+        unsigned long buf_addr;
+        int len;
+        int frame;
+        int isoc_index;
+};
+
+/* HCD data associated with a hardware ETD */
+struct etd_priv {
+        struct usb_host_endpoint *ep;
+        struct urb *urb;
+        struct td *td;
+        struct list_head queue;
+        dma_addr_t dma_handle;
+        int alloc;
+        int len;
+        int dmem_size;
+        int dmem_offset;
+        int active_count;
+#ifdef DEBUG
+        int activated_frame;
+        int disactivated_frame;
+        int last_int_frame;
+        int last_req_frame;
+        u32 submitted_dwords[4];
+#endif
+};
+
+/* Hardware data memory info */
+struct imx21_dmem_area {
+        struct usb_host_endpoint *ep;
+        unsigned int offset;
+        unsigned int size;
+        struct list_head list;
+};
+
+#ifdef DEBUG
+struct debug_usage_stats {
+        unsigned int value;
+        unsigned int maximum;
+};
+
+struct debug_stats {
+        unsigned long submitted;
+        unsigned long completed_ok;
+        unsigned long completed_failed;
+        unsigned long unlinked;
+        unsigned long queue_etd;
+        unsigned long queue_dmem;
+};
+
+struct debug_isoc_trace {
+        int schedule_frame;
+        int submit_frame;
+        int request_len;
+        int done_frame;
+        int done_len;
+        int cc;
+        struct td *td;
+};
+#endif
+
+/* HCD data structure */
+struct imx21 {
+        spinlock_t lock;
+        struct device *dev;
+        struct mx21_usbh_platform_data *pdata;
+        struct list_head dmem_list;
+        struct list_head queue_for_etd; /* eps queued due to etd shortage */
+        struct list_head queue_for_dmem; /* etds queued due to dmem shortage */
+        struct etd_priv etd[USB_NUM_ETD];
+        struct clk *clk;
+        void __iomem *regs;
+#ifdef DEBUG
+        struct dentry *debug_root;
+        struct debug_stats nonisoc_stats;
+        struct debug_stats isoc_stats;
+        struct debug_usage_stats etd_usage;
+        struct debug_usage_stats dmem_usage;
+        struct debug_isoc_trace isoc_trace[20];
+        struct debug_isoc_trace isoc_trace_failed[20];
+        unsigned long debug_unblocks;
+        int isoc_trace_index;
+        int isoc_trace_index_failed;
+#endif
+};
+
+#endif
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index a2b305477afe..92de71dc7729 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -62,6 +62,7 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/usb/isp116x.h>
 #include <linux/platform_device.h>
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index 5c774ab98252..217fb5170200 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -80,7 +80,7 @@
 #include <linux/platform_device.h>
 #include <linux/pm.h>
 #include <linux/io.h>
-#include <linux/bitops.h>
+#include <linux/bitmap.h>
 
 #include <asm/irq.h>
 #include <asm/system.h>
@@ -190,10 +190,8 @@ static int claim_ptd_buffers(struct isp1362_ep_queue *epq,
                              struct isp1362_ep *ep, u16 len)
 {
         int ptd_offset = -EINVAL;
-        int index;
         int num_ptds = ((len + PTD_HEADER_SIZE - 1) / epq->blk_size) + 1;
-        int found = -1;
-        int last = -1;
+        int found;
 
         BUG_ON(len > epq->buf_size);
 
@@ -205,20 +203,9 @@ static int claim_ptd_buffers(struct isp1362_ep_queue *epq,
                     epq->name, len, epq->blk_size, num_ptds, epq->buf_map, epq->skip_map);
         BUG_ON(ep->num_ptds != 0);
 
-        for (index = 0; index <= epq->buf_count - num_ptds; index++) {
-                if (test_bit(index, &epq->buf_map))
-                        continue;
-                found = index;
-                for (last = index + 1; last < index + num_ptds; last++) {
-                        if (test_bit(last, &epq->buf_map)) {
-                                found = -1;
-                                break;
-                        }
-                }
-                if (found >= 0)
-                        break;
-        }
-        if (found < 0)
+        found = bitmap_find_next_zero_area(&epq->buf_map, epq->buf_count, 0,
+                                                num_ptds, 0);
+        if (found >= epq->buf_count)
                 return -EOVERFLOW;
 
         DBG(1, "%s: Found %d PTDs[%d] for %d/%d byte\n", __func__,
@@ -230,8 +217,7 @@ static int claim_ptd_buffers(struct isp1362_ep_queue *epq,
         epq->buf_avail -= num_ptds;
         BUG_ON(epq->buf_avail > epq->buf_count);
         ep->ptd_index = found;
-        for (index = found; index < last; index++)
-                __set_bit(index, &epq->buf_map);
+        bitmap_set(&epq->buf_map, found, num_ptds);
         DBG(1, "%s: Done %s PTD[%d] $%04x, avail %d count %d claimed %d %08lx:%08lx\n",
             __func__, epq->name, ep->ptd_index, ep->ptd_offset,
             epq->buf_avail, epq->buf_count, num_ptds, epq->buf_map, epq->skip_map);
@@ -1271,7 +1257,7 @@ static int isp1362_urb_enqueue(struct usb_hcd *hcd,
 
         /* avoid all allocations within spinlocks: request or endpoint */
         if (!hep->hcpriv) {
-                ep = kcalloc(1, sizeof *ep, mem_flags);
+                ep = kzalloc(sizeof *ep, mem_flags);
                 if (!ep)
                         return -ENOMEM;
         }
@@ -2284,10 +2270,10 @@ static int isp1362_mem_config(struct usb_hcd *hcd)
         dev_info(hcd->self.controller, "ISP1362 Memory usage:\n");
         dev_info(hcd->self.controller, "  ISTL:    2 * %4d:     %4d @ $%04x:$%04x\n",
                  istl_size / 2, istl_size, 0, istl_size / 2);
-        dev_info(hcd->self.controller, "  INTL: %4d * (%3lu+8):  %4d @ $%04x\n",
+        dev_info(hcd->self.controller, "  INTL: %4d * (%3zu+8):  %4d @ $%04x\n",
                  ISP1362_INTL_BUFFERS, intl_blksize - PTD_HEADER_SIZE,
                  intl_size, istl_size);
-        dev_info(hcd->self.controller, "  ATL : %4d * (%3lu+8):  %4d @ $%04x\n",
+        dev_info(hcd->self.controller, "  ATL : %4d * (%3zu+8):  %4d @ $%04x\n",
                  atl_buffers, atl_blksize - PTD_HEADER_SIZE,
                  atl_size, istl_size + intl_size);
         dev_info(hcd->self.controller, "  USED/FREE:   %4d      %4d\n", total,
@@ -2711,6 +2697,8 @@ static int __init isp1362_probe(struct platform_device *pdev)
         void __iomem *data_reg;
         int irq;
         int retval = 0;
+        struct resource *irq_res;
+        unsigned int irq_flags = 0;
 
         /* basic sanity checks first.  board-specific init logic should
          * have initialized this the three resources and probably board
@@ -2724,30 +2712,18 @@ static int __init isp1362_probe(struct platform_device *pdev)
 
         data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        irq = platform_get_irq(pdev, 0);
-        if (!addr || !data || irq < 0) {
+        irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!addr || !data || !irq_res) {
                 retval = -ENODEV;
                 goto err1;
         }
+        irq = irq_res->start;
 
-#ifdef CONFIG_USB_HCD_DMA
-        if (pdev->dev.dma_mask) {
-                struct resource *dma_res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
-
-                if (!dma_res) {
-                        retval = -ENODEV;
-                        goto err1;
-                }
-                isp1362_hcd->data_dma = dma_res->start;
-                isp1362_hcd->max_dma_size = resource_len(dma_res);
-        }
-#else
         if (pdev->dev.dma_mask) {
                 DBG(1, "won't do DMA");
                 retval = -ENODEV;
                 goto err1;
         }
-#endif
 
         if (!request_mem_region(addr->start, resource_len(addr), hcd_name)) {
                 retval = -EBUSY;
@@ -2795,12 +2771,16 @@ static int __init isp1362_probe(struct platform_device *pdev)
         }
 #endif
 
-#ifdef CONFIG_ARM
-        if (isp1362_hcd->board)
-                set_irq_type(irq, isp1362_hcd->board->int_act_high ? IRQT_RISING : IRQT_FALLING);
-#endif
+        if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE)
+                irq_flags |= IRQF_TRIGGER_RISING;
+        if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE)
+                irq_flags |= IRQF_TRIGGER_FALLING;
+        if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL)
+                irq_flags |= IRQF_TRIGGER_HIGH;
+        if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
+                irq_flags |= IRQF_TRIGGER_LOW;
 
-        retval = usb_add_hcd(hcd, irq, IRQF_TRIGGER_LOW | IRQF_DISABLED | IRQF_SHARED);
+        retval = usb_add_hcd(hcd, irq, irq_flags | IRQF_DISABLED | IRQF_SHARED);
         if (retval != 0)
                 goto err6;
         pr_info("%s, irq %d\n", hcd->product_desc, irq);
diff --git a/drivers/usb/host/isp1362.h b/drivers/usb/host/isp1362.h
index 1a253ebf7e50..5151516ea1de 100644
--- a/drivers/usb/host/isp1362.h
+++ b/drivers/usb/host/isp1362.h
@@ -534,8 +534,8 @@ struct isp1362_hcd {
 
         /* periodic schedule: isochronous */
         struct list_head        isoc;
-        int                     istl_flip:1;
-        int                     irq_active:1;
+        unsigned int            istl_flip:1;
+        unsigned int            irq_active:1;
 
         /* Schedules for the current frame */
         struct isp1362_ep_queue atl_queue;
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 9600a58299db..9f01293600b0 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -17,7 +17,9 @@
 #include <linux/debugfs.h>
 #include <linux/uaccess.h>
 #include <linux/io.h>
+#include <linux/mm.h>
 #include <asm/unaligned.h>
+#include <asm/cacheflush.h>
 
 #include "../core/hcd.h"
 #include "isp1760-hcd.h"
@@ -904,6 +906,14 @@ __acquires(priv->lock)
                         status = 0;
         }
 
+        if (usb_pipein(urb->pipe) && usb_pipetype(urb->pipe) != PIPE_CONTROL) {
+                void *ptr;
+                for (ptr = urb->transfer_buffer;
+                     ptr < urb->transfer_buffer + urb->transfer_buffer_length;
+                     ptr += PAGE_SIZE)
+                        flush_dcache_page(virt_to_page(ptr));
+        }
+
         /* complete() can reenter this HCD */
         usb_hcd_unlink_urb_from_ep(priv_to_hcd(priv), urb);
         spin_unlock(&priv->lock);
@@ -1039,12 +1049,12 @@ static void do_atl_int(struct usb_hcd *usb_hcd)
                 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.
+                         * This happens mostly on slower hardware.
                          */
-                        printk(KERN_ERR "Reloading ptd %p/%p... qh %p readed: "
+                        printk(KERN_NOTICE "Reloading ptd %p/%p... qh %p read: "
                                         "%d of %zu done: %08x cur: %08x\n", qtd,
                                         urb, qh, PTD_XFERRED_LENGTH(dw3),
                                         qtd->length, done_map,
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index 1c9f977a5c9c..4293cfd28d61 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -109,7 +109,7 @@ static int of_isp1760_remove(struct of_device *dev)
         return 0;
 }
 
-static struct of_device_id of_isp1760_match[] = {
+static const struct of_device_id of_isp1760_match[] = {
         {
                 .compatible = "nxp,usb-isp1760",
         },
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 7ccffcbe7b6f..944291e10f97 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -35,7 +35,7 @@ extern int usb_disabled(void);
 
 static void at91_start_clock(void)
 {
-        if (cpu_is_at91sam9261())
+        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
                 clk_enable(hclk);
         clk_enable(iclk);
         clk_enable(fclk);
@@ -46,7 +46,7 @@ static void at91_stop_clock(void)
 {
         clk_disable(fclk);
         clk_disable(iclk);
-        if (cpu_is_at91sam9261())
+        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
                 clk_disable(hclk);
         clocked = 0;
 }
@@ -142,7 +142,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
 
         iclk = clk_get(&pdev->dev, "ohci_clk");
         fclk = clk_get(&pdev->dev, "uhpck");
-        if (cpu_is_at91sam9261())
+        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
                 hclk = clk_get(&pdev->dev, "hck0");
 
         at91_start_hc(pdev);
@@ -155,7 +155,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
         /* Error handling */
         at91_stop_hc(pdev);
 
-        if (cpu_is_at91sam9261())
+        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
                 clk_put(hclk);
         clk_put(fclk);
         clk_put(iclk);
@@ -192,7 +192,7 @@ static void usb_hcd_at91_remove(struct usb_hcd *hcd,
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
 
-        if (cpu_is_at91sam9261())
+        if (cpu_is_at91sam9261() || cpu_is_at91sam9g10())
                 clk_put(hclk);
         clk_put(fclk);
         clk_put(iclk);
@@ -331,6 +331,8 @@ ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
          */
         if (at91_suspend_entering_slow_clock()) {
                 ohci_usb_reset (ohci);
+                /* flush the writes */
+                (void) ohci_readl (ohci, &ohci->regs->control);
                 at91_stop_clock();
         }
 
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index e4380082ebb1..17a6043c1fa0 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -294,7 +294,7 @@ static int ohci_hcd_au1xxx_drv_resume(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops au1xxx_ohci_pmops = {
+static const struct dev_pm_ops au1xxx_ohci_pmops = {
         .suspend        = ohci_hcd_au1xxx_drv_suspend,
         .resume         = ohci_hcd_au1xxx_drv_resume,
 };
diff --git a/drivers/usb/host/ohci-da8xx.c b/drivers/usb/host/ohci-da8xx.c
new file mode 100644
index 000000000000..d22fb4d577b7
--- /dev/null
+++ b/drivers/usb/host/ohci-da8xx.c
@@ -0,0 +1,456 @@
+/*
+ * OHCI HCD (Host Controller Driver) for USB.
+ *
+ * TI DA8xx (OMAP-L1x) Bus Glue
+ *
+ * Derived from: ohci-omap.c and ohci-s3c2410.c
+ * Copyright (C) 2008-2009 MontaVista Software, Inc. <source@mvista.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/jiffies.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+#include <mach/da8xx.h>
+#include <mach/usb.h>
+
+#ifndef CONFIG_ARCH_DAVINCI_DA8XX
+#error "This file is DA8xx bus glue.  Define CONFIG_ARCH_DAVINCI_DA8XX."
+#endif
+
+#define CFGCHIP2        DA8XX_SYSCFG0_VIRT(DA8XX_CFGCHIP2_REG)
+
+static struct clk *usb11_clk;
+static struct clk *usb20_clk;
+
+/* Over-current indicator change bitmask */
+static volatile u16 ocic_mask;
+
+static void ohci_da8xx_clock(int on)
+{
+        u32 cfgchip2;
+
+        cfgchip2 = __raw_readl(CFGCHIP2);
+        if (on) {
+                clk_enable(usb11_clk);
+
+                /*
+                 * If USB 1.1 reference clock is sourced from USB 2.0 PHY, we
+                 * need to enable the USB 2.0 module clocking, start its PHY,
+                 * and not allow it to stop the clock during USB 2.0 suspend.
+                 */
+                if (!(cfgchip2 & CFGCHIP2_USB1PHYCLKMUX)) {
+                        clk_enable(usb20_clk);
+
+                        cfgchip2 &= ~(CFGCHIP2_RESET | CFGCHIP2_PHYPWRDN);
+                        cfgchip2 |= CFGCHIP2_PHY_PLLON;
+                        __raw_writel(cfgchip2, CFGCHIP2);
+
+                        pr_info("Waiting for USB PHY clock good...\n");
+                        while (!(__raw_readl(CFGCHIP2) & CFGCHIP2_PHYCLKGD))
+                                cpu_relax();
+                }
+
+                /* Enable USB 1.1 PHY */
+                cfgchip2 |= CFGCHIP2_USB1SUSPENDM;
+        } else {
+                clk_disable(usb11_clk);
+                if (!(cfgchip2 & CFGCHIP2_USB1PHYCLKMUX))
+                        clk_disable(usb20_clk);
+
+                /* Disable USB 1.1 PHY */
+                cfgchip2 &= ~CFGCHIP2_USB1SUSPENDM;
+        }
+        __raw_writel(cfgchip2, CFGCHIP2);
+}
+
+/*
+ * Handle the port over-current indicator change.
+ */
+static void ohci_da8xx_ocic_handler(struct da8xx_ohci_root_hub *hub,
+                                    unsigned port)
+{
+        ocic_mask |= 1 << port;
+
+        /* Once over-current is detected, the port needs to be powered down */
+        if (hub->get_oci(port) > 0)
+                hub->set_power(port, 0);
+}
+
+static int ohci_da8xx_init(struct usb_hcd *hcd)
+{
+        struct device *dev              = hcd->self.controller;
+        struct da8xx_ohci_root_hub *hub = dev->platform_data;
+        struct ohci_hcd *ohci           = hcd_to_ohci(hcd);
+        int result;
+        u32 rh_a;
+
+        dev_dbg(dev, "starting USB controller\n");
+
+        ohci_da8xx_clock(1);
+
+        /*
+         * DA8xx only have 1 port connected to the pins but the HC root hub
+         * register A reports 2 ports, thus we'll have to override it...
+         */
+        ohci->num_ports = 1;
+
+        result = ohci_init(ohci);
+        if (result < 0)
+                return result;
+
+        /*
+         * Since we're providing a board-specific root hub port power control
+         * and over-current reporting, we have to override the HC root hub A
+         * register's default value, so that ohci_hub_control() could return
+         * the correct hub descriptor...
+         */
+        rh_a = ohci_readl(ohci, &ohci->regs->roothub.a);
+        if (hub->set_power) {
+                rh_a &= ~RH_A_NPS;
+                rh_a |=  RH_A_PSM;
+        }
+        if (hub->get_oci) {
+                rh_a &= ~RH_A_NOCP;
+                rh_a |=  RH_A_OCPM;
+        }
+        rh_a &= ~RH_A_POTPGT;
+        rh_a |= hub->potpgt << 24;
+        ohci_writel(ohci, rh_a, &ohci->regs->roothub.a);
+
+        return result;
+}
+
+static void ohci_da8xx_stop(struct usb_hcd *hcd)
+{
+        ohci_stop(hcd);
+        ohci_da8xx_clock(0);
+}
+
+static int ohci_da8xx_start(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci           = hcd_to_ohci(hcd);
+        int result;
+
+        result = ohci_run(ohci);
+        if (result < 0)
+                ohci_da8xx_stop(hcd);
+
+        return result;
+}
+
+/*
+ * Update the status data from the hub with the over-current indicator change.
+ */
+static int ohci_da8xx_hub_status_data(struct usb_hcd *hcd, char *buf)
+{
+        int length              = ohci_hub_status_data(hcd, buf);
+
+        /* See if we have OCIC bit set on port 1 */
+        if (ocic_mask & (1 << 1)) {
+                dev_dbg(hcd->self.controller, "over-current indicator change "
+                        "on port 1\n");
+
+                if (!length)
+                        length = 1;
+
+                buf[0] |= 1 << 1;
+        }
+        return length;
+}
+
+/*
+ * Look at the control requests to the root hub and see if we need to override.
+ */
+static int ohci_da8xx_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                                  u16 wIndex, char *buf, u16 wLength)
+{
+        struct device *dev              = hcd->self.controller;
+        struct da8xx_ohci_root_hub *hub = dev->platform_data;
+        int temp;
+
+        switch (typeReq) {
+        case GetPortStatus:
+                /* Check the port number */
+                if (wIndex != 1)
+                        break;
+
+                dev_dbg(dev, "GetPortStatus(%u)\n", wIndex);
+
+                temp = roothub_portstatus(hcd_to_ohci(hcd), wIndex - 1);
+
+                /* The port power status (PPS) bit defaults to 1 */
+                if (hub->get_power && hub->get_power(wIndex) == 0)
+                        temp &= ~RH_PS_PPS;
+
+                /* The port over-current indicator (POCI) bit is always 0 */
+                if (hub->get_oci && hub->get_oci(wIndex) > 0)
+                        temp |=  RH_PS_POCI;
+
+                /* The over-current indicator change (OCIC) bit is 0 too */
+                if (ocic_mask & (1 << wIndex))
+                        temp |=  RH_PS_OCIC;
+
+                put_unaligned(cpu_to_le32(temp), (__le32 *)buf);
+                return 0;
+        case SetPortFeature:
+                temp = 1;
+                goto check_port;
+        case ClearPortFeature:
+                temp = 0;
+
+check_port:
+                /* Check the port number */
+                if (wIndex != 1)
+                        break;
+
+                switch (wValue) {
+                case USB_PORT_FEAT_POWER:
+                        dev_dbg(dev, "%sPortFeature(%u): %s\n",
+                                temp ? "Set" : "Clear", wIndex, "POWER");
+
+                        if (!hub->set_power)
+                                return -EPIPE;
+
+                        return hub->set_power(wIndex, temp) ? -EPIPE : 0;
+                case USB_PORT_FEAT_C_OVER_CURRENT:
+                        dev_dbg(dev, "%sPortFeature(%u): %s\n",
+                                temp ? "Set" : "Clear", wIndex,
+                                "C_OVER_CURRENT");
+
+                        if (temp)
+                                ocic_mask |= 1 << wIndex;
+                        else
+                                ocic_mask &= ~(1 << wIndex);
+                        return 0;
+                }
+        }
+
+        return ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+}
+
+static const struct hc_driver ohci_da8xx_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "DA8xx OHCI",
+        .hcd_priv_size          = sizeof(struct ohci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ohci_irq,
+        .flags                  = HCD_USB11 | HCD_MEMORY,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                  = ohci_da8xx_init,
+        .start                  = ohci_da8xx_start,
+        .stop                   = ohci_da8xx_stop,
+        .shutdown               = ohci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ohci_urb_enqueue,
+        .urb_dequeue            = ohci_urb_dequeue,
+        .endpoint_disable       = ohci_endpoint_disable,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ohci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ohci_da8xx_hub_status_data,
+        .hub_control            = ohci_da8xx_hub_control,
+
+#ifdef  CONFIG_PM
+        .bus_suspend            = ohci_bus_suspend,
+        .bus_resume             = ohci_bus_resume,
+#endif
+        .start_port_reset       = ohci_start_port_reset,
+};
+
+/*-------------------------------------------------------------------------*/
+
+
+/**
+ * usb_hcd_da8xx_probe - initialize DA8xx-based HCDs
+ * Context: !in_interrupt()
+ *
+ * Allocates basic resources for this USB host controller, and
+ * then invokes the start() method for the HCD associated with it
+ * through the hotplug entry's driver_data.
+ */
+static int usb_hcd_da8xx_probe(const struct hc_driver *driver,
+                               struct platform_device *pdev)
+{
+        struct da8xx_ohci_root_hub *hub = pdev->dev.platform_data;
+        struct usb_hcd  *hcd;
+        struct resource *mem;
+        int error, irq;
+
+        if (hub == NULL)
+                return -ENODEV;
+
+        usb11_clk = clk_get(&pdev->dev, "usb11");
+        if (IS_ERR(usb11_clk))
+                return PTR_ERR(usb11_clk);
+
+        usb20_clk = clk_get(&pdev->dev, "usb20");
+        if (IS_ERR(usb20_clk)) {
+                error = PTR_ERR(usb20_clk);
+                goto err0;
+        }
+
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                error = -ENOMEM;
+                goto err1;
+        }
+
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem) {
+                error = -ENODEV;
+                goto err2;
+        }
+        hcd->rsrc_start = mem->start;
+        hcd->rsrc_len = mem->end - mem->start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                dev_dbg(&pdev->dev, "request_mem_region failed\n");
+                error = -EBUSY;
+                goto err2;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                error = -ENOMEM;
+                goto err3;
+        }
+
+        ohci_hcd_init(hcd_to_ohci(hcd));
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                error = -ENODEV;
+                goto err4;
+        }
+        error = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        if (error)
+                goto err4;
+
+        if (hub->ocic_notify) {
+                error = hub->ocic_notify(ohci_da8xx_ocic_handler);
+                if (!error)
+                        return 0;
+        }
+
+        usb_remove_hcd(hcd);
+err4:
+        iounmap(hcd->regs);
+err3:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err2:
+        usb_put_hcd(hcd);
+err1:
+        clk_put(usb20_clk);
+err0:
+        clk_put(usb11_clk);
+        return error;
+}
+
+/**
+ * usb_hcd_da8xx_remove - shutdown processing for DA8xx-based HCDs
+ * @dev: USB Host Controller being removed
+ * Context: !in_interrupt()
+ *
+ * Reverses the effect of usb_hcd_da8xx_probe(), first invoking
+ * the HCD's stop() method.  It is always called from a thread
+ * context, normally "rmmod", "apmd", or something similar.
+ */
+static inline void
+usb_hcd_da8xx_remove(struct usb_hcd *hcd, struct platform_device *pdev)
+{
+        struct da8xx_ohci_root_hub *hub = pdev->dev.platform_data;
+
+        hub->ocic_notify(NULL);
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        clk_put(usb20_clk);
+        clk_put(usb11_clk);
+}
+
+static int ohci_hcd_da8xx_drv_probe(struct platform_device *dev)
+{
+        return usb_hcd_da8xx_probe(&ohci_da8xx_hc_driver, dev);
+}
+
+static int ohci_hcd_da8xx_drv_remove(struct platform_device *dev)
+{
+        struct usb_hcd  *hcd = platform_get_drvdata(dev);
+
+        usb_hcd_da8xx_remove(hcd, dev);
+        platform_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int ohci_da8xx_suspend(struct platform_device *dev, pm_message_t message)
+{
+        struct usb_hcd  *hcd    = platform_get_drvdata(dev);
+        struct ohci_hcd *ohci   = hcd_to_ohci(hcd);
+
+        if (time_before(jiffies, ohci->next_statechange))
+                msleep(5);
+        ohci->next_statechange = jiffies;
+
+        ohci_da8xx_clock(0);
+        hcd->state = HC_STATE_SUSPENDED;
+        dev->dev.power.power_state = PMSG_SUSPEND;
+        return 0;
+}
+
+static int ohci_da8xx_resume(struct platform_device *dev)
+{
+        struct usb_hcd  *hcd    = platform_get_drvdata(dev);
+        struct ohci_hcd *ohci   = hcd_to_ohci(hcd);
+
+        if (time_before(jiffies, ohci->next_statechange))
+                msleep(5);
+        ohci->next_statechange = jiffies;
+
+        ohci_da8xx_clock(1);
+        dev->dev.power.power_state = PMSG_ON;
+        usb_hcd_resume_root_hub(hcd);
+        return 0;
+}
+#endif
+
+/*
+ * Driver definition to register with platform structure.
+ */
+static struct platform_driver ohci_hcd_da8xx_driver = {
+        .probe          = ohci_hcd_da8xx_drv_probe,
+        .remove         = ohci_hcd_da8xx_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+#ifdef  CONFIG_PM
+        .suspend        = ohci_da8xx_suspend,
+        .resume         = ohci_da8xx_resume,
+#endif
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "ohci",
+        },
+};
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index 811f5dfdc582..8ad2441b0284 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -53,13 +53,13 @@ urb_print(struct urb * urb, char * str, int small, int status)
                 int i, len;
 
                 if (usb_pipecontrol (pipe)) {
-                        printk (KERN_DEBUG __FILE__ ": setup(8):");
+                        printk (KERN_DEBUG "%s: setup(8):", __FILE__);
                         for (i = 0; i < 8 ; i++)
                                 printk (" %02x", ((__u8 *) urb->setup_packet) [i]);
                         printk ("\n");
                 }
                 if (urb->transfer_buffer_length > 0 && urb->transfer_buffer) {
-                        printk (KERN_DEBUG __FILE__ ": data(%d/%d):",
+                        printk (KERN_DEBUG "%s: data(%d/%d):", __FILE__,
                                 urb->actual_length,
                                 urb->transfer_buffer_length);
                         len = usb_pipeout (pipe)?
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 24eb74781919..afe59be23645 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1051,6 +1051,11 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         usb_hcd_pnx4008_driver
 #endif
 
+#ifdef CONFIG_ARCH_DAVINCI_DA8XX
+#include "ohci-da8xx.c"
+#define PLATFORM_DRIVER         ohci_hcd_da8xx_driver
+#endif
+
 #if defined(CONFIG_CPU_SUBTYPE_SH7720) || \
     defined(CONFIG_CPU_SUBTYPE_SH7721) || \
     defined(CONFIG_CPU_SUBTYPE_SH7763) || \
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 32bbce9718f0..65cac8cc8921 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -697,7 +697,7 @@ static int ohci_hub_control (
         u16             wLength
 ) {
         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
-        int             ports = hcd_to_bus (hcd)->root_hub->maxchild;
+        int             ports = ohci->num_ports;
         u32             temp;
         int             retval = 0;
 
diff --git a/drivers/usb/host/ohci-lh7a404.c b/drivers/usb/host/ohci-lh7a404.c
index de42283149c7..18d39f0463ee 100644
--- a/drivers/usb/host/ohci-lh7a404.c
+++ b/drivers/usb/host/ohci-lh7a404.c
@@ -28,8 +28,8 @@ extern int usb_disabled(void);
 
 static void lh7a404_start_hc(struct platform_device *dev)
 {
-        printk(KERN_DEBUG __FILE__
-               ": starting LH7A404 OHCI USB Controller\n");
+        printk(KERN_DEBUG "%s: starting LH7A404 OHCI USB Controller\n",
+               __FILE__);
 
         /*
          * Now, carefully enable the USB clock, and take
@@ -39,14 +39,13 @@ static void lh7a404_start_hc(struct platform_device *dev)
         udelay(1000);
         USBH_CMDSTATUS = OHCI_HCR;
 
-        printk(KERN_DEBUG __FILE__
-                   ": Clock to USB host has been enabled \n");
+        printk(KERN_DEBUG "%s: Clock to USB host has been enabled \n", __FILE__);
 }
 
 static void lh7a404_stop_hc(struct platform_device *dev)
 {
-        printk(KERN_DEBUG __FILE__
-               ": stopping LH7A404 OHCI USB Controller\n");
+        printk(KERN_DEBUG "%s: stopping LH7A404 OHCI USB Controller\n",
+               __FILE__);
 
         CSC_PWRCNT &= ~CSC_PWRCNT_USBH_EN; /* Disable clock */
 }
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index 83cbecd2a1ed..5645f70b9214 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -24,10 +24,10 @@
 #include <asm/io.h>
 #include <asm/mach-types.h>
 
-#include <mach/mux.h>
+#include <plat/mux.h>
 #include <mach/irqs.h>
-#include <mach/fpga.h>
-#include <mach/usb.h>
+#include <plat/fpga.h>
+#include <plat/usb.h>
 
 
 /* OMAP-1510 OHCI has its own MMU for DMA */
diff --git a/drivers/usb/host/ohci-pnx4008.c b/drivers/usb/host/ohci-pnx4008.c
index 100bf3d8437c..cd74bbdd007c 100644
--- a/drivers/usb/host/ohci-pnx4008.c
+++ b/drivers/usb/host/ohci-pnx4008.c
@@ -98,8 +98,8 @@
 #define ISP1301_I2C_INTERRUPT_RISING 0xE
 #define ISP1301_I2C_REG_CLEAR_ADDR 1
 
-struct i2c_driver isp1301_driver;
-struct i2c_client *isp1301_i2c_client;
+static struct i2c_driver isp1301_driver;
+static struct i2c_client *isp1301_i2c_client;
 
 extern int usb_disabled(void);
 extern int ocpi_enable(void);
@@ -120,12 +120,12 @@ static int isp1301_remove(struct i2c_client *client)
         return 0;
 }
 
-const struct i2c_device_id isp1301_id[] = {
+static const struct i2c_device_id isp1301_id[] = {
         { "isp1301_pnx", 0 },
         { }
 };
 
-struct i2c_driver isp1301_driver = {
+static struct i2c_driver isp1301_driver = {
         .driver = {
                 .name = "isp1301_pnx",
         },
@@ -327,7 +327,7 @@ static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev)
         }
         i2c_adap = i2c_get_adapter(2);
         memset(&i2c_info, 0, sizeof(struct i2c_board_info));
-        strlcpy(i2c_info.name, "isp1301_pnx", I2C_NAME_SIZE);
+        strlcpy(i2c_info.type, "isp1301_pnx", I2C_NAME_SIZE);
         isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info,
                                                    normal_i2c);
         i2c_put_adapter(i2c_adap);
@@ -411,7 +411,7 @@ out3:
 out2:
         clk_put(usb_clk);
 out1:
-        i2c_unregister_client(isp1301_i2c_client);
+        i2c_unregister_device(isp1301_i2c_client);
         isp1301_i2c_client = NULL;
 out_i2c_driver:
         i2c_del_driver(&isp1301_driver);
@@ -430,7 +430,7 @@ static int usb_hcd_pnx4008_remove(struct platform_device *pdev)
         pnx4008_unset_usb_bits();
         clk_disable(usb_clk);
         clk_put(usb_clk);
-        i2c_unregister_client(isp1301_i2c_client);
+        i2c_unregister_device(isp1301_i2c_client);
         isp1301_i2c_client = NULL;
         i2c_del_driver(&isp1301_driver);
 
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index 68a301710297..103263c230cf 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -114,21 +114,21 @@ ohci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
         hcd->rsrc_len = res.end - res.start + 1;
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                printk(KERN_ERR __FILE__ ": request_mem_region failed\n");
+                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
                 rv = -EBUSY;
                 goto err_rmr;
         }
 
         irq = irq_of_parse_and_map(dn, 0);
         if (irq == NO_IRQ) {
-                printk(KERN_ERR __FILE__ ": irq_of_parse_and_map failed\n");
+                printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
                 rv = -EBUSY;
                 goto err_irq;
         }
 
         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
         if (!hcd->regs) {
-                printk(KERN_ERR __FILE__ ": ioremap failed\n");
+                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
                 rv = -ENOMEM;
                 goto err_ioremap;
         }
@@ -169,7 +169,7 @@ ohci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
                         } else
                                 release_mem_region(res.start, 0x4);
                 } else
-                    pr_debug(__FILE__ ": cannot get ehci offset from fdt\n");
+                        pr_debug("%s: cannot get ehci offset from fdt\n", __FILE__);
         }
 
         iounmap(hcd->regs);
@@ -212,7 +212,7 @@ static int ohci_hcd_ppc_of_shutdown(struct of_device *op)
 }
 
 
-static struct of_device_id ohci_hcd_ppc_of_match[] = {
+static const struct of_device_id ohci_hcd_ppc_of_match[] = {
 #ifdef CONFIG_USB_OHCI_HCD_PPC_OF_BE
         {
                 .name = "usb",
diff --git a/drivers/usb/host/ohci-ppc-soc.c b/drivers/usb/host/ohci-ppc-soc.c
index cd3398b675b2..89e670e38c10 100644
--- a/drivers/usb/host/ohci-ppc-soc.c
+++ b/drivers/usb/host/ohci-ppc-soc.c
@@ -41,14 +41,14 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
 
         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (!res) {
-                pr_debug(__FILE__ ": no irq\n");
+                pr_debug("%s: no irq\n", __FILE__);
                 return -ENODEV;
         }
         irq = res->start;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
-                pr_debug(__FILE__ ": no reg addr\n");
+                pr_debug("%s: no reg addr\n", __FILE__);
                 return -ENODEV;
         }
 
@@ -59,14 +59,14 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
         hcd->rsrc_len = res->end - res->start + 1;
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                pr_debug(__FILE__ ": request_mem_region failed\n");
+                pr_debug("%s: request_mem_region failed\n", __FILE__);
                 retval = -EBUSY;
                 goto err1;
         }
 
         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
         if (!hcd->regs) {
-                pr_debug(__FILE__ ": ioremap failed\n");
+                pr_debug("%s: ioremap failed\n", __FILE__);
                 retval = -ENOMEM;
                 goto err2;
         }
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index f1c06202fdf2..a18debdd79b8 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -518,7 +518,7 @@ static int ohci_hcd_pxa27x_drv_resume(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops ohci_hcd_pxa27x_pm_ops = {
+static const struct dev_pm_ops ohci_hcd_pxa27x_pm_ops = {
         .suspend        = ohci_hcd_pxa27x_drv_suspend,
         .resume         = ohci_hcd_pxa27x_drv_resume,
 };
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 35288bcae0db..83094d067e0f 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -8,6 +8,7 @@
  */
 
 #include <linux/irq.h>
+#include <linux/slab.h>
 
 static void urb_free_priv (struct ohci_hcd *hc, urb_priv_t *urb_priv)
 {
diff --git a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
index e4bbe8e188e4..d8eb3bdafabb 100644
--- a/drivers/usb/host/ohci-sa1111.c
+++ b/drivers/usb/host/ohci-sa1111.c
@@ -31,8 +31,8 @@ static void sa1111_start_hc(struct sa1111_dev *dev)
 {
         unsigned int usb_rst = 0;
 
-        printk(KERN_DEBUG __FILE__
-               ": starting SA-1111 OHCI USB Controller\n");
+        printk(KERN_DEBUG "%s: starting SA-1111 OHCI USB Controller\n",
+               __FILE__);
 
 #ifdef CONFIG_SA1100_BADGE4
         if (machine_is_badge4()) {
@@ -65,8 +65,8 @@ static void sa1111_start_hc(struct sa1111_dev *dev)
 static void sa1111_stop_hc(struct sa1111_dev *dev)
 {
         unsigned int usb_rst;
-        printk(KERN_DEBUG __FILE__
-               ": stopping SA-1111 OHCI USB Controller\n");
+        printk(KERN_DEBUG "%s: stopping SA-1111 OHCI USB Controller\n",
+               __FILE__);
 
         /*
          * Put the USB host controller into reset.
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 50f57f468836..e62b30b3e429 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -660,13 +660,13 @@ static struct ehci_qh *oxu_qh_alloc(struct oxu_hcd *oxu)
                 if (qh->dummy == NULL) {
                         oxu_dbg(oxu, "no dummy td\n");
                         oxu->qh_used[i] = 0;
-
-                        return NULL;
+                        qh = NULL;
+                        goto unlock;
                 }
 
                 oxu->qh_used[i] = 1;
         }
-
+unlock:
         spin_unlock(&oxu->mem_lock);
 
         return qh;
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index e33d36256350..d478ffad59b4 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -35,7 +35,10 @@
 #include <linux/usb.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/mm.h>
 #include <linux/irq.h>
+#include <linux/slab.h>
+#include <asm/cacheflush.h>
 
 #include "../core/hcd.h"
 #include "r8a66597.h"
@@ -216,8 +219,17 @@ static void disable_controller(struct r8a66597 *r8a66597)
 {
         int port;
 
+        /* disable interrupts */
         r8a66597_write(r8a66597, 0, INTENB0);
-        r8a66597_write(r8a66597, 0, INTSTS0);
+        r8a66597_write(r8a66597, 0, INTENB1);
+        r8a66597_write(r8a66597, 0, BRDYENB);
+        r8a66597_write(r8a66597, 0, BEMPENB);
+        r8a66597_write(r8a66597, 0, NRDYENB);
+
+        /* clear status */
+        r8a66597_write(r8a66597, 0, BRDYSTS);
+        r8a66597_write(r8a66597, 0, NRDYSTS);
+        r8a66597_write(r8a66597, 0, BEMPSTS);
 
         for (port = 0; port < r8a66597->max_root_hub; port++)
                 r8a66597_disable_port(r8a66597, port);
@@ -407,7 +419,7 @@ static u8 alloc_usb_address(struct r8a66597 *r8a66597, struct urb *urb)
 
 /* this function must be called with interrupt disabled */
 static void free_usb_address(struct r8a66597 *r8a66597,
-                             struct r8a66597_device *dev)
+                             struct r8a66597_device *dev, int reset)
 {
         int port;
 
@@ -419,7 +431,13 @@ static void free_usb_address(struct r8a66597 *r8a66597,
         dev->state = USB_STATE_DEFAULT;
         r8a66597->address_map &= ~(1 << dev->address);
         dev->address = 0;
-        dev_set_drvdata(&dev->udev->dev, NULL);
+        /*
+         * Only when resetting USB, it is necessary to erase drvdata. When
+         * a usb device with usb hub is disconnect, "dev->udev" is already
+         * freed on usb_desconnect(). So we cannot access the data.
+         */
+        if (reset)
+                dev_set_drvdata(&dev->udev->dev, NULL);
         list_del(&dev->device_list);
         kfree(dev);
 
@@ -811,6 +829,26 @@ static void enable_r8a66597_pipe(struct r8a66597 *r8a66597, struct urb *urb,
         enable_r8a66597_pipe_dma(r8a66597, dev, pipe, urb);
 }
 
+static void r8a66597_urb_done(struct r8a66597 *r8a66597, struct urb *urb,
+                              int status)
+__releases(r8a66597->lock)
+__acquires(r8a66597->lock)
+{
+        if (usb_pipein(urb->pipe) && usb_pipetype(urb->pipe) != PIPE_CONTROL) {
+                void *ptr;
+
+                for (ptr = urb->transfer_buffer;
+                     ptr < urb->transfer_buffer + urb->transfer_buffer_length;
+                     ptr += PAGE_SIZE)
+                        flush_dcache_page(virt_to_page(ptr));
+        }
+
+        usb_hcd_unlink_urb_from_ep(r8a66597_to_hcd(r8a66597), urb);
+        spin_unlock(&r8a66597->lock);
+        usb_hcd_giveback_urb(r8a66597_to_hcd(r8a66597), urb, status);
+        spin_lock(&r8a66597->lock);
+}
+
 /* this function must be called with interrupt disabled */
 static void force_dequeue(struct r8a66597 *r8a66597, u16 pipenum, u16 address)
 {
@@ -822,8 +860,6 @@ static void force_dequeue(struct r8a66597 *r8a66597, u16 pipenum, u16 address)
                 return;
 
         list_for_each_entry_safe(td, next, list, queue) {
-                if (!td)
-                        continue;
                 if (td->address != address)
                         continue;
 
@@ -831,15 +867,9 @@ static void force_dequeue(struct r8a66597 *r8a66597, u16 pipenum, u16 address)
                 list_del(&td->queue);
                 kfree(td);
 
-                if (urb) {
-                        usb_hcd_unlink_urb_from_ep(r8a66597_to_hcd(r8a66597),
-                                        urb);
+                if (urb)
+                        r8a66597_urb_done(r8a66597, urb, -ENODEV);
 
-                        spin_unlock(&r8a66597->lock);
-                        usb_hcd_giveback_urb(r8a66597_to_hcd(r8a66597), urb,
-                                        -ENODEV);
-                        spin_lock(&r8a66597->lock);
-                }
                 break;
         }
 }
@@ -999,6 +1029,8 @@ static void start_root_hub_sampling(struct r8a66597 *r8a66597, int port,
 /* this function must be called with interrupt disabled */
 static void r8a66597_check_syssts(struct r8a66597 *r8a66597, int port,
                                         u16 syssts)
+__releases(r8a66597->lock)
+__acquires(r8a66597->lock)
 {
         if (syssts == SE0) {
                 r8a66597_write(r8a66597, ~ATTCH, get_intsts_reg(port));
@@ -1016,7 +1048,9 @@ static void r8a66597_check_syssts(struct r8a66597 *r8a66597, int port,
                         usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
         }
 
+        spin_unlock(&r8a66597->lock);
         usb_hcd_poll_rh_status(r8a66597_to_hcd(r8a66597));
+        spin_lock(&r8a66597->lock);
 }
 
 /* this function must be called with interrupt disabled */
@@ -1042,7 +1076,7 @@ static void r8a66597_usb_disconnect(struct r8a66597 *r8a66597, int port)
         struct r8a66597_device *dev = r8a66597->root_hub[port].dev;
 
         disable_r8a66597_pipe_all(r8a66597, dev);
-        free_usb_address(r8a66597, dev);
+        free_usb_address(r8a66597, dev, 0);
 
         start_root_hub_sampling(r8a66597, port, 0);
 }
@@ -1276,10 +1310,7 @@ __releases(r8a66597->lock) __acquires(r8a66597->lock)
                 if (usb_pipeisoc(urb->pipe))
                         urb->start_frame = r8a66597_get_frame(hcd);
 
-                usb_hcd_unlink_urb_from_ep(r8a66597_to_hcd(r8a66597), urb);
-                spin_unlock(&r8a66597->lock);
-                usb_hcd_giveback_urb(hcd, urb, status);
-                spin_lock(&r8a66597->lock);
+                r8a66597_urb_done(r8a66597, urb, status);
         }
 
         if (restart) {
@@ -2025,8 +2056,6 @@ static struct r8a66597_device *get_r8a66597_device(struct r8a66597 *r8a66597,
         struct list_head *list = &r8a66597->child_device;
 
         list_for_each_entry(dev, list, device_list) {
-                if (!dev)
-                        continue;
                 if (dev->usb_address != addr)
                         continue;
 
@@ -2063,7 +2092,7 @@ static void update_usb_address_map(struct r8a66597 *r8a66597,
                                 spin_lock_irqsave(&r8a66597->lock, flags);
                                 dev = get_r8a66597_device(r8a66597, addr);
                                 disable_r8a66597_pipe_all(r8a66597, dev);
-                                free_usb_address(r8a66597, dev);
+                                free_usb_address(r8a66597, dev, 0);
                                 put_child_connect_map(r8a66597, addr);
                                 spin_unlock_irqrestore(&r8a66597->lock, flags);
                         }
@@ -2206,7 +2235,7 @@ static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         rh->port |= (1 << USB_PORT_FEAT_RESET);
 
                         disable_r8a66597_pipe_all(r8a66597, dev);
-                        free_usb_address(r8a66597, dev);
+                        free_usb_address(r8a66597, dev, 1);
 
                         r8a66597_mdfy(r8a66597, USBRST, USBRST | UACT,
                                       get_dvstctr_reg(port));
@@ -2357,7 +2386,7 @@ static int r8a66597_resume(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops r8a66597_dev_pm_ops = {
+static const struct dev_pm_ops r8a66597_dev_pm_ops = {
         .suspend = r8a66597_suspend,
         .resume = r8a66597_resume,
         .poweroff = r8a66597_suspend,
@@ -2470,6 +2499,12 @@ static int __devinit r8a66597_probe(struct platform_device *pdev)
         r8a66597->rh_timer.data = (unsigned long)r8a66597;
         r8a66597->reg = (unsigned long)reg;
 
+        /* make sure no interrupts are pending */
+        ret = r8a66597_clock_enable(r8a66597);
+        if (ret < 0)
+                goto clean_up3;
+        disable_controller(r8a66597);
+
         for (i = 0; i < R8A66597_MAX_NUM_PIPE; i++) {
                 INIT_LIST_HEAD(&r8a66597->pipe_queue[i]);
                 init_timer(&r8a66597->td_timer[i]);
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 5b22a4d1c9e4..3b867a8af7b2 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -51,6 +51,7 @@
 #include <asm/irq.h>
 #include <asm/system.h>
 #include <asm/byteorder.h>
+#include <asm/unaligned.h>
 
 #include "../core/hcd.h"
 #include "sl811.h"
@@ -719,10 +720,10 @@ retry:
                 /* port status seems weird until after reset, so
                  * force the reset and make khubd clean up later.
                  */
-                if (sl811->stat_insrmv & 1)
-                        sl811->port1 |= 1 << USB_PORT_FEAT_CONNECTION;
-                else
+                if (irqstat & SL11H_INTMASK_RD)
                         sl811->port1 &= ~(1 << USB_PORT_FEAT_CONNECTION);
+                else
+                        sl811->port1 |= 1 << USB_PORT_FEAT_CONNECTION;
 
                 sl811->port1 |= 1 << USB_PORT_FEAT_C_CONNECTION;
 
@@ -1272,12 +1273,12 @@ sl811h_hub_control(
                 sl811h_hub_descriptor(sl811, (struct usb_hub_descriptor *) buf);
                 break;
         case GetHubStatus:
-                *(__le32 *) buf = cpu_to_le32(0);
+                put_unaligned_le32(0, buf);
                 break;
         case GetPortStatus:
                 if (wIndex != 1)
                         goto error;
-                *(__le32 *) buf = cpu_to_le32(sl811->port1);
+                put_unaligned_le32(sl811->port1, buf);
 
 #ifndef VERBOSE
         if (*(u16*)(buf+2))     /* only if wPortChange is interesting */
diff --git a/drivers/usb/host/sl811_cs.c b/drivers/usb/host/sl811_cs.c
index 516848dd9b48..39d253e841f6 100644
--- a/drivers/usb/host/sl811_cs.c
+++ b/drivers/usb/host/sl811_cs.c
@@ -37,28 +37,8 @@ MODULE_LICENSE("GPL");
 /* MACROS                                                             */
 /*====================================================================*/
 
-#if defined(DEBUG) || defined(PCMCIA_DEBUG)
-
-static int pc_debug = 0;
-module_param(pc_debug, int, 0644);
-
-#define DBG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG "sl811_cs: " args)
-
-#else
-#define DBG(n, args...) do{}while(0)
-#endif  /* no debugging */
-
 #define INFO(args...) printk(KERN_INFO "sl811_cs: " args)
 
-#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
-
-#define CS_CHECK(fn, ret) \
-        do { \
-                last_fn = (fn); \
-                if ((last_ret = (ret)) != 0) \
-                        goto cs_failed; \
-        } while (0)
-
 /*====================================================================*/
 /* VARIABLES                                                          */
 /*====================================================================*/
@@ -76,7 +56,7 @@ static void sl811_cs_release(struct pcmcia_device * link);
 
 static void release_platform_dev(struct device * dev)
 {
-        DBG(0, "sl811_cs platform_dev release\n");
+        dev_dbg(dev, "sl811_cs platform_dev release\n");
         dev->parent = NULL;
 }
 
@@ -140,7 +120,7 @@ static int sl811_hc_init(struct device *parent, resource_size_t base_addr,
 
 static void sl811_cs_detach(struct pcmcia_device *link)
 {
-        DBG(0, "sl811_cs_detach(0x%p)\n", link);
+        dev_dbg(&link->dev, "sl811_cs_detach\n");
 
         sl811_cs_release(link);
 
@@ -150,7 +130,7 @@ static void sl811_cs_detach(struct pcmcia_device *link)
 
 static void sl811_cs_release(struct pcmcia_device * link)
 {
-        DBG(0, "sl811_cs_release(0x%p)\n", link);
+        dev_dbg(&link->dev, "sl811_cs_release\n");
 
         pcmcia_disable_device(link);
         platform_device_unregister(&platform_dev);
@@ -205,11 +185,11 @@ static int sl811_cs_config_check(struct pcmcia_device *p_dev,
 
 static int sl811_cs_config(struct pcmcia_device *link)
 {
-        struct device           *parent = &handle_to_dev(link);
+        struct device           *parent = &link->dev;
         local_info_t            *dev = link->priv;
-        int                     last_fn, last_ret;
+        int                     ret;
 
-        DBG(0, "sl811_cs_config(0x%p)\n", link);
+        dev_dbg(&link->dev, "sl811_cs_config\n");
 
         if (pcmcia_loop_config(link, sl811_cs_config_check, NULL))
                 goto failed;
@@ -217,14 +197,16 @@ static int sl811_cs_config(struct pcmcia_device *link)
         /* require an IRQ and two registers */
         if (!link->io.NumPorts1 || link->io.NumPorts1 < 2)
                 goto failed;
-        if (link->conf.Attributes & CONF_ENABLE_IRQ)
-                CS_CHECK(RequestIRQ,
-                        pcmcia_request_irq(link, &link->irq));
-        else
+        if (link->conf.Attributes & CONF_ENABLE_IRQ) {
+                ret = pcmcia_request_irq(link, &link->irq);
+                if (ret)
+                        goto failed;
+        } else
                 goto failed;
 
-        CS_CHECK(RequestConfiguration,
-                pcmcia_request_configuration(link, &link->conf));
+        ret = pcmcia_request_configuration(link, &link->conf);
+        if (ret)
+                goto failed;
 
         sprintf(dev->node.dev_name, driver_name);
         dev->node.major = dev->node.minor = 0;
@@ -241,8 +223,6 @@ static int sl811_cs_config(struct pcmcia_device *link)
 
         if (sl811_hc_init(parent, link->io.BasePort1, link->irq.AssignedIRQ)
                         < 0) {
-cs_failed:
-                cs_error(link, last_fn, last_ret);
 failed:
                 printk(KERN_WARNING "sl811_cs_config failed\n");
                 sl811_cs_release(link);
@@ -263,7 +243,6 @@ static int sl811_cs_probe(struct pcmcia_device *link)
 
         /* Initialize */
         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
-        link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
         link->irq.Handler = NULL;
 
         link->conf.Attributes = 0;
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index e52b954dda47..98cf0b26b968 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -9,6 +9,7 @@
  * (C) Copyright 1999-2001 Johannes Erdfelt
  */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/debugfs.h>
 #include <linux/smp_lock.h>
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 5cd0e48f67fb..09197067fe6b 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -735,6 +735,7 @@ static void uhci_stop(struct usb_hcd *hcd)
                 uhci_hc_died(uhci);
         uhci_scan_schedule(uhci);
         spin_unlock_irq(&uhci->lock);
+        synchronize_irq(hcd->irq);
 
         del_timer_sync(&uhci->fsbr_timer);
         release_uhci(uhci);
@@ -749,7 +750,20 @@ static int uhci_rh_suspend(struct usb_hcd *hcd)
         spin_lock_irq(&uhci->lock);
         if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
                 rc = -ESHUTDOWN;
-        else if (!uhci->dead)
+        else if (uhci->dead)
+                ;               /* Dead controllers tell no tales */
+
+        /* Once the controller is stopped, port resumes that are already
+         * in progress won't complete.  Hence if remote wakeup is enabled
+         * for the root hub and any ports are in the middle of a resume or
+         * remote wakeup, we must fail the suspend.
+         */
+        else if (hcd->self.root_hub->do_remote_wakeup &&
+                        uhci->resuming_ports) {
+                dev_dbg(uhci_dev(uhci), "suspend failed because a port "
+                                "is resuming\n");
+                rc = -EBUSY;
+        } else
                 suspend_rh(uhci, UHCI_RH_SUSPENDED);
         spin_unlock_irq(&uhci->lock);
         return rc;
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 885b585360b9..8270055848ca 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -167,7 +167,7 @@ static void uhci_check_ports(struct uhci_hcd *uhci)
                                 /* Port received a wakeup request */
                                 set_bit(port, &uhci->resuming_ports);
                                 uhci->ports_timeout = jiffies +
-                                                msecs_to_jiffies(20);
+                                                msecs_to_jiffies(25);
 
                                 /* Make sure we see the port again
                                  * after the resuming period is over. */
diff --git a/drivers/usb/host/whci/asl.c b/drivers/usb/host/whci/asl.c
index 562eba108816..773249306031 100644
--- a/drivers/usb/host/whci/asl.c
+++ b/drivers/usb/host/whci/asl.c
@@ -16,6 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/dma-mapping.h>
 #include <linux/uwb/umc.h>
 #include <linux/usb.h>
diff --git a/drivers/usb/host/whci/debug.c b/drivers/usb/host/whci/debug.c
index 2273c815941f..c5305b599ca0 100644
--- a/drivers/usb/host/whci/debug.c
+++ b/drivers/usb/host/whci/debug.c
@@ -15,6 +15,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
@@ -31,17 +32,29 @@ struct whc_dbg {
 
 void qset_print(struct seq_file *s, struct whc_qset *qset)
 {
+        static const char *qh_type[] = {
+                "ctrl", "isoc", "bulk", "intr", "rsvd", "rsvd", "rsvd", "lpintr", };
         struct whc_std *std;
         struct urb *urb = NULL;
         int i;
 
-        seq_printf(s, "qset %08x\n", (u32)qset->qset_dma);
+        seq_printf(s, "qset %08x", (u32)qset->qset_dma);
+        if (&qset->list_node == qset->whc->async_list.prev) {
+                seq_printf(s, " (dummy)\n");
+        } else {
+                seq_printf(s, " ep%d%s-%s maxpkt: %d\n",
+                           qset->qh.info1 & 0x0f,
+                           (qset->qh.info1 >> 4) & 0x1 ? "in" : "out",
+                           qh_type[(qset->qh.info1 >> 5) & 0x7],
+                           (qset->qh.info1 >> 16) & 0xffff);
+        }
         seq_printf(s, "  -> %08x\n", (u32)qset->qh.link);
         seq_printf(s, "  info: %08x %08x %08x\n",
-                qset->qh.info1, qset->qh.info2,  qset->qh.info3);
-        seq_printf(s, "  sts: %04x errs: %d\n", qset->qh.status, qset->qh.err_count);
+                   qset->qh.info1, qset->qh.info2,  qset->qh.info3);
+        seq_printf(s, "  sts: %04x errs: %d curwin: %08x\n",
+                   qset->qh.status, qset->qh.err_count, qset->qh.cur_window);
         seq_printf(s, "  TD: sts: %08x opts: %08x\n",
-                qset->qh.overlay.qtd.status, qset->qh.overlay.qtd.options);
+                   qset->qh.overlay.qtd.status, qset->qh.overlay.qtd.options);
 
         for (i = 0; i < WHCI_QSET_TD_MAX; i++) {
                 seq_printf(s, "  %c%c TD[%d]: sts: %08x opts: %08x ptr: %08x\n",
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index 687b622a1612..e0d3401285c8 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -250,6 +250,7 @@ static int whc_probe(struct umc_dev *umc)
         }
 
         usb_hcd->wireless = 1;
+        usb_hcd->self.sg_tablesize = 2048; /* somewhat arbitrary */
 
         wusbhc = usb_hcd_to_wusbhc(usb_hcd);
         whc = wusbhc_to_whc(wusbhc);
diff --git a/drivers/usb/host/whci/init.c b/drivers/usb/host/whci/init.c
index 34a783cb0133..f7582e8e2169 100644
--- a/drivers/usb/host/whci/init.c
+++ b/drivers/usb/host/whci/init.c
@@ -16,6 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/dma-mapping.h>
 #include <linux/uwb/umc.h>
 
diff --git a/drivers/usb/host/whci/pzl.c b/drivers/usb/host/whci/pzl.c
index 0db3fb2dc03a..33c5580b4d25 100644
--- a/drivers/usb/host/whci/pzl.c
+++ b/drivers/usb/host/whci/pzl.c
@@ -16,6 +16,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/dma-mapping.h>
 #include <linux/uwb/umc.h>
 #include <linux/usb.h>
diff --git a/drivers/usb/host/whci/qset.c b/drivers/usb/host/whci/qset.c
index 1b9dc1571570..141d049beb3e 100644
--- a/drivers/usb/host/whci/qset.c
+++ b/drivers/usb/host/whci/qset.c
@@ -17,6 +17,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/dma-mapping.h>
+#include <linux/slab.h>
 #include <linux/uwb/umc.h>
 #include <linux/usb.h>
 
@@ -49,16 +50,19 @@ struct whc_qset *qset_alloc(struct whc *whc, gfp_t mem_flags)
  *        state
  * @urb:  an urb for a transfer to this endpoint
  */
-static void qset_fill_qh(struct whc_qset *qset, struct urb *urb)
+static void qset_fill_qh(struct whc *whc, struct whc_qset *qset, struct urb *urb)
 {
         struct usb_device *usb_dev = urb->dev;
+        struct wusb_dev *wusb_dev = usb_dev->wusb_dev;
         struct usb_wireless_ep_comp_descriptor *epcd;
         bool is_out;
+        uint8_t phy_rate;
 
         is_out = usb_pipeout(urb->pipe);
 
-        epcd = (struct usb_wireless_ep_comp_descriptor *)qset->ep->extra;
+        qset->max_packet = le16_to_cpu(urb->ep->desc.wMaxPacketSize);
 
+        epcd = (struct usb_wireless_ep_comp_descriptor *)qset->ep->extra;
         if (epcd) {
                 qset->max_seq = epcd->bMaxSequence;
                 qset->max_burst = epcd->bMaxBurst;
@@ -67,12 +71,28 @@ static void qset_fill_qh(struct whc_qset *qset, struct urb *urb)
                 qset->max_burst = 1;
         }
 
+        /*
+         * Initial PHY rate is 53.3 Mbit/s for control endpoints or
+         * the maximum supported by the device for other endpoints
+         * (unless limited by the user).
+         */
+        if (usb_pipecontrol(urb->pipe))
+                phy_rate = UWB_PHY_RATE_53;
+        else {
+                uint16_t phy_rates;
+
+                phy_rates = le16_to_cpu(wusb_dev->wusb_cap_descr->wPHYRates);
+                phy_rate = fls(phy_rates) - 1;
+                if (phy_rate > whc->wusbhc.phy_rate)
+                        phy_rate = whc->wusbhc.phy_rate;
+        }
+
         qset->qh.info1 = cpu_to_le32(
                 QH_INFO1_EP(usb_pipeendpoint(urb->pipe))
                 | (is_out ? QH_INFO1_DIR_OUT : QH_INFO1_DIR_IN)
                 | usb_pipe_to_qh_type(urb->pipe)
                 | QH_INFO1_DEV_INFO_IDX(wusb_port_no_to_idx(usb_dev->portnum))
-                | QH_INFO1_MAX_PKT_LEN(usb_maxpacket(urb->dev, urb->pipe, is_out))
+                | QH_INFO1_MAX_PKT_LEN(qset->max_packet)
                 );
         qset->qh.info2 = cpu_to_le32(
                 QH_INFO2_BURST(qset->max_burst)
@@ -86,7 +106,7 @@ static void qset_fill_qh(struct whc_qset *qset, struct urb *urb)
          * strength and can presumably guess the Tx power required
          * from that? */
         qset->qh.info3 = cpu_to_le32(
-                QH_INFO3_TX_RATE_53_3
+                QH_INFO3_TX_RATE(phy_rate)
                 | QH_INFO3_TX_PWR(0) /* 0 == max power */
                 );
 
@@ -148,7 +168,7 @@ struct whc_qset *get_qset(struct whc *whc, struct urb *urb,
 
                 qset->ep = urb->ep;
                 urb->ep->hcpriv = qset;
-                qset_fill_qh(qset, urb);
+                qset_fill_qh(whc, qset, urb);
         }
         return qset;
 }
@@ -241,6 +261,36 @@ static void qset_remove_qtd(struct whc *whc, struct whc_qset *qset)
         qset->ntds--;
 }
 
+static void qset_copy_bounce_to_sg(struct whc *whc, struct whc_std *std)
+{
+        struct scatterlist *sg;
+        void *bounce;
+        size_t remaining, offset;
+
+        bounce = std->bounce_buf;
+        remaining = std->len;
+
+        sg = std->bounce_sg;
+        offset = std->bounce_offset;
+
+        while (remaining) {
+                size_t len;
+
+                len = min(sg->length - offset, remaining);
+                memcpy(sg_virt(sg) + offset, bounce, len);
+
+                bounce += len;
+                remaining -= len;
+
+                offset += len;
+                if (offset >= sg->length) {
+                        sg = sg_next(sg);
+                        offset = 0;
+                }
+        }
+
+}
+
 /**
  * qset_free_std - remove an sTD and free it.
  * @whc: the WHCI host controller
@@ -249,13 +299,29 @@ static void qset_remove_qtd(struct whc *whc, struct whc_qset *qset)
 void qset_free_std(struct whc *whc, struct whc_std *std)
 {
         list_del(&std->list_node);
-        if (std->num_pointers) {
-                dma_unmap_single(whc->wusbhc.dev, std->dma_addr,
-                                 std->num_pointers * sizeof(struct whc_page_list_entry),
-                                 DMA_TO_DEVICE);
+        if (std->bounce_buf) {
+                bool is_out = usb_pipeout(std->urb->pipe);
+                dma_addr_t dma_addr;
+
+                if (std->num_pointers)
+                        dma_addr = le64_to_cpu(std->pl_virt[0].buf_ptr);
+                else
+                        dma_addr = std->dma_addr;
+
+                dma_unmap_single(whc->wusbhc.dev, dma_addr,
+                                 std->len, is_out ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                if (!is_out)
+                        qset_copy_bounce_to_sg(whc, std);
+                kfree(std->bounce_buf);
+        }
+        if (std->pl_virt) {
+                if (std->dma_addr)
+                        dma_unmap_single(whc->wusbhc.dev, std->dma_addr,
+                                         std->num_pointers * sizeof(struct whc_page_list_entry),
+                                         DMA_TO_DEVICE);
                 kfree(std->pl_virt);
+                std->pl_virt = NULL;
         }
-
         kfree(std);
 }
 
@@ -293,12 +359,17 @@ static int qset_fill_page_list(struct whc *whc, struct whc_std *std, gfp_t mem_f
 {
         dma_addr_t dma_addr = std->dma_addr;
         dma_addr_t sp, ep;
-        size_t std_len = std->len;
         size_t pl_len;
         int p;
 
-        sp = ALIGN(dma_addr, WHCI_PAGE_SIZE);
-        ep = dma_addr + std_len;
+        /* Short buffers don't need a page list. */
+        if (std->len <= WHCI_PAGE_SIZE) {
+                std->num_pointers = 0;
+                return 0;
+        }
+
+        sp = dma_addr & ~(WHCI_PAGE_SIZE-1);
+        ep = dma_addr + std->len;
         std->num_pointers = DIV_ROUND_UP(ep - sp, WHCI_PAGE_SIZE);
 
         pl_len = std->num_pointers * sizeof(struct whc_page_list_entry);
@@ -309,7 +380,7 @@ static int qset_fill_page_list(struct whc *whc, struct whc_std *std, gfp_t mem_f
 
         for (p = 0; p < std->num_pointers; p++) {
                 std->pl_virt[p].buf_ptr = cpu_to_le64(dma_addr);
-                dma_addr = ALIGN(dma_addr + WHCI_PAGE_SIZE, WHCI_PAGE_SIZE);
+                dma_addr = (dma_addr + WHCI_PAGE_SIZE) & ~(WHCI_PAGE_SIZE-1);
         }
 
         return 0;
@@ -339,6 +410,218 @@ static void urb_dequeue_work(struct work_struct *work)
         spin_unlock_irqrestore(&whc->lock, flags);
 }
 
+static struct whc_std *qset_new_std(struct whc *whc, struct whc_qset *qset,
+                                    struct urb *urb, gfp_t mem_flags)
+{
+        struct whc_std *std;
+
+        std = kzalloc(sizeof(struct whc_std), mem_flags);
+        if (std == NULL)
+                return NULL;
+
+        std->urb = urb;
+        std->qtd = NULL;
+
+        INIT_LIST_HEAD(&std->list_node);
+        list_add_tail(&std->list_node, &qset->stds);
+
+        return std;
+}
+
+static int qset_add_urb_sg(struct whc *whc, struct whc_qset *qset, struct urb *urb,
+                           gfp_t mem_flags)
+{
+        size_t remaining;
+        struct scatterlist *sg;
+        int i;
+        int ntds = 0;
+        struct whc_std *std = NULL;
+        struct whc_page_list_entry *entry;
+        dma_addr_t prev_end = 0;
+        size_t pl_len;
+        int p = 0;
+
+        remaining = urb->transfer_buffer_length;
+
+        for_each_sg(urb->sg->sg, sg, urb->num_sgs, i) {
+                dma_addr_t dma_addr;
+                size_t dma_remaining;
+                dma_addr_t sp, ep;
+                int num_pointers;
+
+                if (remaining == 0) {
+                        break;
+                }
+
+                dma_addr = sg_dma_address(sg);
+                dma_remaining = min_t(size_t, sg_dma_len(sg), remaining);
+
+                while (dma_remaining) {
+                        size_t dma_len;
+
+                        /*
+                         * We can use the previous std (if it exists) provided that:
+                         * - the previous one ended on a page boundary.
+                         * - the current one begins on a page boundary.
+                         * - the previous one isn't full.
+                         *
+                         * If a new std is needed but the previous one
+                         * was not a whole number of packets then this
+                         * sg list cannot be mapped onto multiple
+                         * qTDs.  Return an error and let the caller
+                         * sort it out.
+                         */
+                        if (!std
+                            || (prev_end & (WHCI_PAGE_SIZE-1))
+                            || (dma_addr & (WHCI_PAGE_SIZE-1))
+                            || std->len + WHCI_PAGE_SIZE > QTD_MAX_XFER_SIZE) {
+                                if (std->len % qset->max_packet != 0)
+                                        return -EINVAL;
+                                std = qset_new_std(whc, qset, urb, mem_flags);
+                                if (std == NULL) {
+                                        return -ENOMEM;
+                                }
+                                ntds++;
+                                p = 0;
+                        }
+
+                        dma_len = dma_remaining;
+
+                        /*
+                         * If the remainder of this element doesn't
+                         * fit in a single qTD, limit the qTD to a
+                         * whole number of packets.  This allows the
+                         * remainder to go into the next qTD.
+                         */
+                        if (std->len + dma_len > QTD_MAX_XFER_SIZE) {
+                                dma_len = (QTD_MAX_XFER_SIZE / qset->max_packet)
+                                        * qset->max_packet - std->len;
+                        }
+
+                        std->len += dma_len;
+                        std->ntds_remaining = -1; /* filled in later */
+
+                        sp = dma_addr & ~(WHCI_PAGE_SIZE-1);
+                        ep = dma_addr + dma_len;
+                        num_pointers = DIV_ROUND_UP(ep - sp, WHCI_PAGE_SIZE);
+                        std->num_pointers += num_pointers;
+
+                        pl_len = std->num_pointers * sizeof(struct whc_page_list_entry);
+
+                        std->pl_virt = krealloc(std->pl_virt, pl_len, mem_flags);
+                        if (std->pl_virt == NULL) {
+                                return -ENOMEM;
+                        }
+
+                        for (;p < std->num_pointers; p++, entry++) {
+                                std->pl_virt[p].buf_ptr = cpu_to_le64(dma_addr);
+                                dma_addr = (dma_addr + WHCI_PAGE_SIZE) & ~(WHCI_PAGE_SIZE-1);
+                        }
+
+                        prev_end = dma_addr = ep;
+                        dma_remaining -= dma_len;
+                        remaining -= dma_len;
+                }
+        }
+
+        /* Now the number of stds is know, go back and fill in
+           std->ntds_remaining. */
+        list_for_each_entry(std, &qset->stds, list_node) {
+                if (std->ntds_remaining == -1) {
+                        pl_len = std->num_pointers * sizeof(struct whc_page_list_entry);
+                        std->ntds_remaining = ntds--;
+                        std->dma_addr = dma_map_single(whc->wusbhc.dev, std->pl_virt,
+                                                       pl_len, DMA_TO_DEVICE);
+                }
+        }
+        return 0;
+}
+
+/**
+ * qset_add_urb_sg_linearize - add an urb with sg list, copying the data
+ *
+ * If the URB contains an sg list whose elements cannot be directly
+ * mapped to qTDs then the data must be transferred via bounce
+ * buffers.
+ */
+static int qset_add_urb_sg_linearize(struct whc *whc, struct whc_qset *qset,
+                                     struct urb *urb, gfp_t mem_flags)
+{
+        bool is_out = usb_pipeout(urb->pipe);
+        size_t max_std_len;
+        size_t remaining;
+        int ntds = 0;
+        struct whc_std *std = NULL;
+        void *bounce = NULL;
+        struct scatterlist *sg;
+        int i;
+
+        /* limit maximum bounce buffer to 16 * 3.5 KiB ~= 28 k */
+        max_std_len = qset->max_burst * qset->max_packet;
+
+        remaining = urb->transfer_buffer_length;
+
+        for_each_sg(urb->sg->sg, sg, urb->sg->nents, i) {
+                size_t len;
+                size_t sg_remaining;
+                void *orig;
+
+                if (remaining == 0) {
+                        break;
+                }
+
+                sg_remaining = min_t(size_t, remaining, sg->length);
+                orig = sg_virt(sg);
+
+                while (sg_remaining) {
+                        if (!std || std->len == max_std_len) {
+                                std = qset_new_std(whc, qset, urb, mem_flags);
+                                if (std == NULL)
+                                        return -ENOMEM;
+                                std->bounce_buf = kmalloc(max_std_len, mem_flags);
+                                if (std->bounce_buf == NULL)
+                                        return -ENOMEM;
+                                std->bounce_sg = sg;
+                                std->bounce_offset = orig - sg_virt(sg);
+                                bounce = std->bounce_buf;
+                                ntds++;
+                        }
+
+                        len = min(sg_remaining, max_std_len - std->len);
+
+                        if (is_out)
+                                memcpy(bounce, orig, len);
+
+                        std->len += len;
+                        std->ntds_remaining = -1; /* filled in later */
+
+                        bounce += len;
+                        orig += len;
+                        sg_remaining -= len;
+                        remaining -= len;
+                }
+        }
+
+        /*
+         * For each of the new sTDs, map the bounce buffers, create
+         * page lists (if necessary), and fill in std->ntds_remaining.
+         */
+        list_for_each_entry(std, &qset->stds, list_node) {
+                if (std->ntds_remaining != -1)
+                        continue;
+
+                std->dma_addr = dma_map_single(&whc->umc->dev, std->bounce_buf, std->len,
+                                               is_out ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+
+                if (qset_fill_page_list(whc, std, mem_flags) < 0)
+                        return -ENOMEM;
+
+                std->ntds_remaining = ntds--;
+        }
+
+        return 0;
+}
+
 /**
  * qset_add_urb - add an urb to the qset's queue.
  *
@@ -353,10 +636,7 @@ int qset_add_urb(struct whc *whc, struct whc_qset *qset, struct urb *urb,
         int remaining = urb->transfer_buffer_length;
         u64 transfer_dma = urb->transfer_dma;
         int ntds_remaining;
-
-        ntds_remaining = DIV_ROUND_UP(remaining, QTD_MAX_XFER_SIZE);
-        if (ntds_remaining == 0)
-                ntds_remaining = 1;
+        int ret;
 
         wurb = kzalloc(sizeof(struct whc_urb), mem_flags);
         if (wurb == NULL)
@@ -366,32 +646,39 @@ int qset_add_urb(struct whc *whc, struct whc_qset *qset, struct urb *urb,
         wurb->urb = urb;
         INIT_WORK(&wurb->dequeue_work, urb_dequeue_work);
 
+        if (urb->sg) {
+                ret = qset_add_urb_sg(whc, qset, urb, mem_flags);
+                if (ret == -EINVAL) {
+                        qset_free_stds(qset, urb);
+                        ret = qset_add_urb_sg_linearize(whc, qset, urb, mem_flags);
+                }
+                if (ret < 0)
+                        goto err_no_mem;
+                return 0;
+        }
+
+        ntds_remaining = DIV_ROUND_UP(remaining, QTD_MAX_XFER_SIZE);
+        if (ntds_remaining == 0)
+                ntds_remaining = 1;
+
         while (ntds_remaining) {
                 struct whc_std *std;
                 size_t std_len;
 
-                std = kmalloc(sizeof(struct whc_std), mem_flags);
-                if (std == NULL)
-                        goto err_no_mem;
-
                 std_len = remaining;
                 if (std_len > QTD_MAX_XFER_SIZE)
                         std_len = QTD_MAX_XFER_SIZE;
 
-                std->urb = urb;
+                std = qset_new_std(whc, qset, urb, mem_flags);
+                if (std == NULL)
+                        goto err_no_mem;
+
                 std->dma_addr = transfer_dma;
                 std->len = std_len;
                 std->ntds_remaining = ntds_remaining;
-                std->qtd = NULL;
 
-                INIT_LIST_HEAD(&std->list_node);
-                list_add_tail(&std->list_node, &qset->stds);
-
-                if (std_len > WHCI_PAGE_SIZE) {
-                        if (qset_fill_page_list(whc, std, mem_flags) < 0)
-                                goto err_no_mem;
-                } else
-                        std->num_pointers = 0;
+                if (qset_fill_page_list(whc, std, mem_flags) < 0)
+                        goto err_no_mem;
 
                 ntds_remaining--;
                 remaining -= std_len;
diff --git a/drivers/usb/host/whci/whcd.h b/drivers/usb/host/whci/whcd.h
index 24e94d983c5e..c80c7d93bc4a 100644
--- a/drivers/usb/host/whci/whcd.h
+++ b/drivers/usb/host/whci/whcd.h
@@ -84,6 +84,11 @@ struct whc {
  * @len: the length of data in the associated TD.
  * @ntds_remaining: number of TDs (starting from this one) in this transfer.
  *
+ * @bounce_buf: a bounce buffer if the std was from an urb with a sg
+ * list that could not be mapped to qTDs directly.
+ * @bounce_sg: the first scatterlist element bounce_buf is for.
+ * @bounce_offset: the offset into bounce_sg for the start of bounce_buf.
+ *
  * Queued URBs may require more TDs than are available in a qset so we
  * use a list of these "software TDs" (sTDs) to hold per-TD data.
  */
@@ -97,6 +102,10 @@ struct whc_std {
         int num_pointers;
         dma_addr_t dma_addr;
         struct whc_page_list_entry *pl_virt;
+
+        void *bounce_buf;
+        struct scatterlist *bounce_sg;
+        unsigned bounce_offset;
 };
 
 /**
diff --git a/drivers/usb/host/whci/whci-hc.h b/drivers/usb/host/whci/whci-hc.h
index e8d0001605be..4d4cbc0730bf 100644
--- a/drivers/usb/host/whci/whci-hc.h
+++ b/drivers/usb/host/whci/whci-hc.h
@@ -172,14 +172,7 @@ struct whc_qhead {
 #define QH_INFO3_MAX_DELAY(d)    ((d) << 0)  /* maximum stream delay in 125 us units (isoc only) */
 #define QH_INFO3_INTERVAL(i)     ((i) << 16) /* segment interval in 125 us units (isoc only) */
 
-#define QH_INFO3_TX_RATE_53_3    (0 << 24)
-#define QH_INFO3_TX_RATE_80      (1 << 24)
-#define QH_INFO3_TX_RATE_106_7   (2 << 24)
-#define QH_INFO3_TX_RATE_160     (3 << 24)
-#define QH_INFO3_TX_RATE_200     (4 << 24)
-#define QH_INFO3_TX_RATE_320     (5 << 24)
-#define QH_INFO3_TX_RATE_400     (6 << 24)
-#define QH_INFO3_TX_RATE_480     (7 << 24)
+#define QH_INFO3_TX_RATE(r)      ((r) << 24) /* PHY rate (see [ECMA-368] section 10.3.1.1) */
 #define QH_INFO3_TX_PWR(p)       ((p) << 29) /* transmit power (see [WUSB] section 5.2.1.2) */
 
 #define QH_STATUS_FLOW_CTRL      (1 << 15)
@@ -267,8 +260,9 @@ struct whc_qset {
         unsigned reset:1;
         struct urb *pause_after_urb;
         struct completion remove_complete;
-        int max_burst;
-        int max_seq;
+        uint16_t max_packet;
+        uint8_t max_burst;
+        uint8_t max_seq;
 };
 
 static inline void whc_qset_set_link_ptr(u64 *ptr, u64 target)
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index 33128d52f212..105fa8b025bb 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -406,6 +406,25 @@ static void dbg_rsvd64(struct xhci_hcd *xhci, u64 *ctx, dma_addr_t dma)
         }
 }
 
+char *xhci_get_slot_state(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *ctx)
+{
+        struct xhci_slot_ctx *slot_ctx = xhci_get_slot_ctx(xhci, ctx);
+
+        switch (GET_SLOT_STATE(slot_ctx->dev_state)) {
+        case 0:
+                return "enabled/disabled";
+        case 1:
+                return "default";
+        case 2:
+                return "addressed";
+        case 3:
+                return "configured";
+        default:
+                return "reserved";
+        }
+}
+
 void xhci_dbg_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx)
 {
         /* Fields are 32 bits wide, DMA addresses are in bytes */
diff --git a/drivers/usb/host/xhci-ext-caps.h b/drivers/usb/host/xhci-ext-caps.h
index ecc131c3fe33..78c4edac1db1 100644
--- a/drivers/usb/host/xhci-ext-caps.h
+++ b/drivers/usb/host/xhci-ext-caps.h
@@ -101,12 +101,15 @@ static inline int xhci_find_next_cap_offset(void __iomem *base, int ext_offset)
 
         next = readl(base + ext_offset);
 
-        if (ext_offset == XHCI_HCC_PARAMS_OFFSET)
+        if (ext_offset == XHCI_HCC_PARAMS_OFFSET) {
                 /* Find the first extended capability */
                 next = XHCI_HCC_EXT_CAPS(next);
-        else
+                ext_offset = 0;
+        } else {
                 /* Find the next extended capability */
                 next = XHCI_EXT_CAPS_NEXT(next);
+        }
+
         if (!next)
                 return 0;
         /*
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index eac5b53aa9e7..208b805b80eb 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -129,6 +129,50 @@ static u32 xhci_port_state_to_neutral(u32 state)
         return (state & XHCI_PORT_RO) | (state & XHCI_PORT_RWS);
 }
 
+static void xhci_disable_port(struct xhci_hcd *xhci, u16 wIndex,
+                u32 __iomem *addr, u32 port_status)
+{
+        /* Write 1 to disable the port */
+        xhci_writel(xhci, port_status | PORT_PE, addr);
+        port_status = xhci_readl(xhci, addr);
+        xhci_dbg(xhci, "disable port, actual port %d status  = 0x%x\n",
+                        wIndex, port_status);
+}
+
+static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
+                u16 wIndex, u32 __iomem *addr, u32 port_status)
+{
+        char *port_change_bit;
+        u32 status;
+
+        switch (wValue) {
+        case USB_PORT_FEAT_C_RESET:
+                status = PORT_RC;
+                port_change_bit = "reset";
+                break;
+        case USB_PORT_FEAT_C_CONNECTION:
+                status = PORT_CSC;
+                port_change_bit = "connect";
+                break;
+        case USB_PORT_FEAT_C_OVER_CURRENT:
+                status = PORT_OCC;
+                port_change_bit = "over-current";
+                break;
+        case USB_PORT_FEAT_C_ENABLE:
+                status = PORT_PEC;
+                port_change_bit = "enable/disable";
+                break;
+        default:
+                /* Should never happen */
+                return;
+        }
+        /* Change bits are all write 1 to clear */
+        xhci_writel(xhci, port_status | status, addr);
+        port_status = xhci_readl(xhci, addr);
+        xhci_dbg(xhci, "clear port %s change, actual port %d status  = 0x%x\n",
+                        port_change_bit, wIndex, port_status);
+}
+
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 u16 wIndex, char *buf, u16 wLength)
 {
@@ -138,7 +182,6 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
         u32 temp, status;
         int retval = 0;
         u32 __iomem *addr;
-        char *port_change_bit;
 
         ports = HCS_MAX_PORTS(xhci->hcs_params1);
 
@@ -229,26 +272,18 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 temp = xhci_port_state_to_neutral(temp);
                 switch (wValue) {
                 case USB_PORT_FEAT_C_RESET:
-                        status = PORT_RC;
-                        port_change_bit = "reset";
-                        break;
                 case USB_PORT_FEAT_C_CONNECTION:
-                        status = PORT_CSC;
-                        port_change_bit = "connect";
-                        break;
                 case USB_PORT_FEAT_C_OVER_CURRENT:
-                        status = PORT_OCC;
-                        port_change_bit = "over-current";
+                case USB_PORT_FEAT_C_ENABLE:
+                        xhci_clear_port_change_bit(xhci, wValue, wIndex,
+                                        addr, temp);
+                        break;
+                case USB_PORT_FEAT_ENABLE:
+                        xhci_disable_port(xhci, wIndex, addr, temp);
                         break;
                 default:
                         goto error;
                 }
-                /* Change bits are all write 1 to clear */
-                xhci_writel(xhci, temp | status, addr);
-                temp = xhci_readl(xhci, addr);
-                xhci_dbg(xhci, "clear port %s change, actual port %d status  = 0x%x\n",
-                                port_change_bit, wIndex, temp);
-                temp = xhci_readl(xhci, addr); /* unblock any posted writes */
                 break;
         default:
 error:
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index b8fd270a8b0d..d64f5724bfc4 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -22,6 +22,7 @@
 
 #include <linux/usb.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/dmapool.h>
 
 #include "xhci.h"
@@ -125,6 +126,23 @@ void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring)
         kfree(ring);
 }
 
+static void xhci_initialize_ring_info(struct xhci_ring *ring)
+{
+        /* The ring is empty, so the enqueue pointer == dequeue pointer */
+        ring->enqueue = ring->first_seg->trbs;
+        ring->enq_seg = ring->first_seg;
+        ring->dequeue = ring->enqueue;
+        ring->deq_seg = ring->first_seg;
+        /* The ring is initialized to 0. The producer must write 1 to the cycle
+         * bit to handover ownership of the TRB, so PCS = 1.  The consumer must
+         * compare CCS to the cycle bit to check ownership, so CCS = 1.
+         */
+        ring->cycle_state = 1;
+        /* Not necessary for new rings, but needed for re-initialized rings */
+        ring->enq_updates = 0;
+        ring->deq_updates = 0;
+}
+
 /**
  * Create a new ring with zero or more segments.
  *
@@ -173,17 +191,7 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci,
                                 " segment %p (virtual), 0x%llx (DMA)\n",
                                 prev, (unsigned long long)prev->dma);
         }
-        /* The ring is empty, so the enqueue pointer == dequeue pointer */
-        ring->enqueue = ring->first_seg->trbs;
-        ring->enq_seg = ring->first_seg;
-        ring->dequeue = ring->enqueue;
-        ring->deq_seg = ring->first_seg;
-        /* The ring is initialized to 0. The producer must write 1 to the cycle
-         * bit to handover ownership of the TRB, so PCS = 1.  The consumer must
-         * compare CCS to the cycle bit to check ownership, so CCS = 1.
-         */
-        ring->cycle_state = 1;
-
+        xhci_initialize_ring_info(ring);
         return ring;
 
 fail:
@@ -191,6 +199,52 @@ fail:
         return 0;
 }
 
+void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                unsigned int ep_index)
+{
+        int rings_cached;
+
+        rings_cached = virt_dev->num_rings_cached;
+        if (rings_cached < XHCI_MAX_RINGS_CACHED) {
+                virt_dev->num_rings_cached++;
+                rings_cached = virt_dev->num_rings_cached;
+                virt_dev->ring_cache[rings_cached] =
+                        virt_dev->eps[ep_index].ring;
+                xhci_dbg(xhci, "Cached old ring, "
+                                "%d ring%s cached\n",
+                                rings_cached,
+                                (rings_cached > 1) ? "s" : "");
+        } else {
+                xhci_ring_free(xhci, virt_dev->eps[ep_index].ring);
+                xhci_dbg(xhci, "Ring cache full (%d rings), "
+                                "freeing ring\n",
+                                virt_dev->num_rings_cached);
+        }
+        virt_dev->eps[ep_index].ring = NULL;
+}
+
+/* Zero an endpoint ring (except for link TRBs) and move the enqueue and dequeue
+ * pointers to the beginning of the ring.
+ */
+static void xhci_reinit_cached_ring(struct xhci_hcd *xhci,
+                struct xhci_ring *ring)
+{
+        struct xhci_segment     *seg = ring->first_seg;
+        do {
+                memset(seg->trbs, 0,
+                                sizeof(union xhci_trb)*TRBS_PER_SEGMENT);
+                /* All endpoint rings have link TRBs */
+                xhci_link_segments(xhci, seg, seg->next, 1);
+                seg = seg->next;
+        } while (seg != ring->first_seg);
+        xhci_initialize_ring_info(ring);
+        /* td list should be empty since all URBs have been cancelled,
+         * but just in case...
+         */
+        INIT_LIST_HEAD(&ring->td_list);
+}
+
 #define CTX_SIZE(_hcc) (HCC_64BYTE_CONTEXT(_hcc) ? 64 : 32)
 
 struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci,
@@ -214,6 +268,8 @@ struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci,
 void xhci_free_container_ctx(struct xhci_hcd *xhci,
                              struct xhci_container_ctx *ctx)
 {
+        if (!ctx)
+                return;
         dma_pool_free(xhci->device_pool, ctx->bytes, ctx->dma);
         kfree(ctx);
 }
@@ -248,6 +304,15 @@ struct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci,
                 (ctx->bytes + (ep_index * CTX_SIZE(xhci->hcc_params)));
 }
 
+static void xhci_init_endpoint_timer(struct xhci_hcd *xhci,
+                struct xhci_virt_ep *ep)
+{
+        init_timer(&ep->stop_cmd_timer);
+        ep->stop_cmd_timer.data = (unsigned long) ep;
+        ep->stop_cmd_timer.function = xhci_stop_endpoint_command_watchdog;
+        ep->xhci = xhci;
+}
+
 /* All the xhci_tds in the ring's TD list should be freed at this point */
 void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
 {
@@ -267,6 +332,12 @@ void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
                 if (dev->eps[i].ring)
                         xhci_ring_free(xhci, dev->eps[i].ring);
 
+        if (dev->ring_cache) {
+                for (i = 0; i < dev->num_rings_cached; i++)
+                        xhci_ring_free(xhci, dev->ring_cache[i]);
+                kfree(dev->ring_cache);
+        }
+
         if (dev->in_ctx)
                 xhci_free_container_ctx(xhci, dev->in_ctx);
         if (dev->out_ctx)
@@ -309,15 +380,25 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
         xhci_dbg(xhci, "Slot %d input ctx = 0x%llx (dma)\n", slot_id,
                         (unsigned long long)dev->in_ctx->dma);
 
-        /* Initialize the cancellation list for each endpoint */
-        for (i = 0; i < 31; i++)
+        /* Initialize the cancellation list and watchdog timers for each ep */
+        for (i = 0; i < 31; i++) {
+                xhci_init_endpoint_timer(xhci, &dev->eps[i]);
                 INIT_LIST_HEAD(&dev->eps[i].cancelled_td_list);
+        }
 
         /* Allocate endpoint 0 ring */
         dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, flags);
         if (!dev->eps[0].ring)
                 goto fail;
 
+        /* Allocate pointers to the ring cache */
+        dev->ring_cache = kzalloc(
+                        sizeof(struct xhci_ring *)*XHCI_MAX_RINGS_CACHED,
+                        flags);
+        if (!dev->ring_cache)
+                goto fail;
+        dev->num_rings_cached = 0;
+
         init_completion(&dev->cmd_completion);
         INIT_LIST_HEAD(&dev->cmd_list);
 
@@ -374,7 +455,7 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         case USB_SPEED_LOW:
                 slot_ctx->dev_info |= (u32) SLOT_SPEED_LS;
                 break;
-        case USB_SPEED_VARIABLE:
+        case USB_SPEED_WIRELESS:
                 xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
                 return -EINVAL;
                 break;
@@ -418,7 +499,7 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud
         case USB_SPEED_LOW:
                 ep0_ctx->ep_info2 |= MAX_PACKET(8);
                 break;
-        case USB_SPEED_VARIABLE:
+        case USB_SPEED_WIRELESS:
                 xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
                 return -EINVAL;
                 break;
@@ -486,8 +567,13 @@ static inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
                         if (interval < 3)
                                 interval = 3;
                         if ((1 << interval) != 8*ep->desc.bInterval)
-                                dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n",
-                                                ep->desc.bEndpointAddress, 1 << interval);
+                                dev_warn(&udev->dev,
+                                                "ep %#x - rounding interval"
+                                                " to %d microframes, "
+                                                "ep desc says %d microframes\n",
+                                                ep->desc.bEndpointAddress,
+                                                1 << interval,
+                                                8*ep->desc.bInterval);
                 }
                 break;
         default:
@@ -496,6 +582,19 @@ static inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
         return EP_INTERVAL(interval);
 }
 
+/* The "Mult" field in the endpoint context is only set for SuperSpeed devices.
+ * High speed endpoint descriptors can define "the number of additional
+ * transaction opportunities per microframe", but that goes in the Max Burst
+ * endpoint context field.
+ */
+static inline u32 xhci_get_endpoint_mult(struct usb_device *udev,
+                struct usb_host_endpoint *ep)
+{
+        if (udev->speed != USB_SPEED_SUPER || !ep->ss_ep_comp)
+                return 0;
+        return ep->ss_ep_comp->desc.bmAttributes;
+}
+
 static inline u32 xhci_get_endpoint_type(struct usb_device *udev,
                 struct usb_host_endpoint *ep)
 {
@@ -526,6 +625,36 @@ static inline u32 xhci_get_endpoint_type(struct usb_device *udev,
         return type;
 }
 
+/* Return the maximum endpoint service interval time (ESIT) payload.
+ * Basically, this is the maxpacket size, multiplied by the burst size
+ * and mult size.
+ */
+static inline u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
+                struct usb_device *udev,
+                struct usb_host_endpoint *ep)
+{
+        int max_burst;
+        int max_packet;
+
+        /* Only applies for interrupt or isochronous endpoints */
+        if (usb_endpoint_xfer_control(&ep->desc) ||
+                        usb_endpoint_xfer_bulk(&ep->desc))
+                return 0;
+
+        if (udev->speed == USB_SPEED_SUPER) {
+                if (ep->ss_ep_comp)
+                        return ep->ss_ep_comp->desc.wBytesPerInterval;
+                xhci_warn(xhci, "WARN no SS endpoint companion descriptor.\n");
+                /* Assume no bursts, no multiple opportunities to send. */
+                return ep->desc.wMaxPacketSize;
+        }
+
+        max_packet = ep->desc.wMaxPacketSize & 0x3ff;
+        max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11;
+        /* A 0 in max burst means 1 transfer per ESIT */
+        return max_packet * (max_burst + 1);
+}
+
 int xhci_endpoint_init(struct xhci_hcd *xhci,
                 struct xhci_virt_device *virt_dev,
                 struct usb_device *udev,
@@ -537,6 +666,7 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
         struct xhci_ring *ep_ring;
         unsigned int max_packet;
         unsigned int max_burst;
+        u32 max_esit_payload;
 
         ep_index = xhci_get_endpoint_index(&ep->desc);
         ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index);
@@ -544,12 +674,21 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
         /* Set up the endpoint ring */
         virt_dev->eps[ep_index].new_ring =
                 xhci_ring_alloc(xhci, 1, true, mem_flags);
-        if (!virt_dev->eps[ep_index].new_ring)
-                return -ENOMEM;
+        if (!virt_dev->eps[ep_index].new_ring) {
+                /* Attempt to use the ring cache */
+                if (virt_dev->num_rings_cached == 0)
+                        return -ENOMEM;
+                virt_dev->eps[ep_index].new_ring =
+                        virt_dev->ring_cache[virt_dev->num_rings_cached];
+                virt_dev->ring_cache[virt_dev->num_rings_cached] = NULL;
+                virt_dev->num_rings_cached--;
+                xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring);
+        }
         ep_ring = virt_dev->eps[ep_index].new_ring;
         ep_ctx->deq = ep_ring->first_seg->dma | ep_ring->cycle_state;
 
         ep_ctx->ep_info = xhci_get_endpoint_interval(udev, ep);
+        ep_ctx->ep_info |= EP_MULT(xhci_get_endpoint_mult(udev, ep));
 
         /* FIXME dig Mult and streams info out of ep companion desc */
 
@@ -595,6 +734,26 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
         default:
                 BUG();
         }
+        max_esit_payload = xhci_get_max_esit_payload(xhci, udev, ep);
+        ep_ctx->tx_info = MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload);
+
+        /*
+         * XXX no idea how to calculate the average TRB buffer length for bulk
+         * endpoints, as the driver gives us no clue how big each scatter gather
+         * list entry (or buffer) is going to be.
+         *
+         * For isochronous and interrupt endpoints, we set it to the max
+         * available, until we have new API in the USB core to allow drivers to
+         * declare how much bandwidth they actually need.
+         *
+         * Normally, it would be calculated by taking the total of the buffer
+         * lengths in the TD and then dividing by the number of TRBs in a TD,
+         * including link TRBs, No-op TRBs, and Event data TRBs.  Since we don't
+         * use Event Data TRBs, and we don't chain in a link TRB on short
+         * transfers, we're basically dividing by 1.
+         */
+        ep_ctx->tx_info |= AVG_TRB_LENGTH_FOR_EP(max_esit_payload);
+
         /* FIXME Debug endpoint context */
         return 0;
 }
@@ -758,7 +917,8 @@ static void scratchpad_free(struct xhci_hcd *xhci)
 }
 
 struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
-                bool allocate_completion, gfp_t mem_flags)
+                bool allocate_in_ctx, bool allocate_completion,
+                gfp_t mem_flags)
 {
         struct xhci_command *command;
 
@@ -766,16 +926,22 @@ struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
         if (!command)
                 return NULL;
 
-        command->in_ctx =
-                xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT, mem_flags);
-        if (!command->in_ctx)
-                return NULL;
+        if (allocate_in_ctx) {
+                command->in_ctx =
+                        xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT,
+                                        mem_flags);
+                if (!command->in_ctx) {
+                        kfree(command);
+                        return NULL;
+                }
+        }
 
         if (allocate_completion) {
                 command->completion =
                         kzalloc(sizeof(struct completion), mem_flags);
                 if (!command->completion) {
                         xhci_free_container_ctx(xhci, command->in_ctx);
+                        kfree(command);
                         return NULL;
                 }
                 init_completion(command->completion);
@@ -848,6 +1014,163 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         xhci->page_shift = 0;
 }
 
+static int xhci_test_trb_in_td(struct xhci_hcd *xhci,
+                struct xhci_segment *input_seg,
+                union xhci_trb *start_trb,
+                union xhci_trb *end_trb,
+                dma_addr_t input_dma,
+                struct xhci_segment *result_seg,
+                char *test_name, int test_number)
+{
+        unsigned long long start_dma;
+        unsigned long long end_dma;
+        struct xhci_segment *seg;
+
+        start_dma = xhci_trb_virt_to_dma(input_seg, start_trb);
+        end_dma = xhci_trb_virt_to_dma(input_seg, end_trb);
+
+        seg = trb_in_td(input_seg, start_trb, end_trb, input_dma);
+        if (seg != result_seg) {
+                xhci_warn(xhci, "WARN: %s TRB math test %d failed!\n",
+                                test_name, test_number);
+                xhci_warn(xhci, "Tested TRB math w/ seg %p and "
+                                "input DMA 0x%llx\n",
+                                input_seg,
+                                (unsigned long long) input_dma);
+                xhci_warn(xhci, "starting TRB %p (0x%llx DMA), "
+                                "ending TRB %p (0x%llx DMA)\n",
+                                start_trb, start_dma,
+                                end_trb, end_dma);
+                xhci_warn(xhci, "Expected seg %p, got seg %p\n",
+                                result_seg, seg);
+                return -1;
+        }
+        return 0;
+}
+
+/* TRB math checks for xhci_trb_in_td(), using the command and event rings. */
+static int xhci_check_trb_in_td_math(struct xhci_hcd *xhci, gfp_t mem_flags)
+{
+        struct {
+                dma_addr_t              input_dma;
+                struct xhci_segment     *result_seg;
+        } simple_test_vector [] = {
+                /* A zeroed DMA field should fail */
+                { 0, NULL },
+                /* One TRB before the ring start should fail */
+                { xhci->event_ring->first_seg->dma - 16, NULL },
+                /* One byte before the ring start should fail */
+                { xhci->event_ring->first_seg->dma - 1, NULL },
+                /* Starting TRB should succeed */
+                { xhci->event_ring->first_seg->dma, xhci->event_ring->first_seg },
+                /* Ending TRB should succeed */
+                { xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 1)*16,
+                        xhci->event_ring->first_seg },
+                /* One byte after the ring end should fail */
+                { xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 1)*16 + 1, NULL },
+                /* One TRB after the ring end should fail */
+                { xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT)*16, NULL },
+                /* An address of all ones should fail */
+                { (dma_addr_t) (~0), NULL },
+        };
+        struct {
+                struct xhci_segment     *input_seg;
+                union xhci_trb          *start_trb;
+                union xhci_trb          *end_trb;
+                dma_addr_t              input_dma;
+                struct xhci_segment     *result_seg;
+        } complex_test_vector [] = {
+                /* Test feeding a valid DMA address from a different ring */
+                {       .input_seg = xhci->event_ring->first_seg,
+                        .start_trb = xhci->event_ring->first_seg->trbs,
+                        .end_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1],
+                        .input_dma = xhci->cmd_ring->first_seg->dma,
+                        .result_seg = NULL,
+                },
+                /* Test feeding a valid end TRB from a different ring */
+                {       .input_seg = xhci->event_ring->first_seg,
+                        .start_trb = xhci->event_ring->first_seg->trbs,
+                        .end_trb = &xhci->cmd_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1],
+                        .input_dma = xhci->cmd_ring->first_seg->dma,
+                        .result_seg = NULL,
+                },
+                /* Test feeding a valid start and end TRB from a different ring */
+                {       .input_seg = xhci->event_ring->first_seg,
+                        .start_trb = xhci->cmd_ring->first_seg->trbs,
+                        .end_trb = &xhci->cmd_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1],
+                        .input_dma = xhci->cmd_ring->first_seg->dma,
+                        .result_seg = NULL,
+                },
+                /* TRB in this ring, but after this TD */
+                {       .input_seg = xhci->event_ring->first_seg,
+                        .start_trb = &xhci->event_ring->first_seg->trbs[0],
+                        .end_trb = &xhci->event_ring->first_seg->trbs[3],
+                        .input_dma = xhci->event_ring->first_seg->dma + 4*16,
+                        .result_seg = NULL,
+                },
+                /* TRB in this ring, but before this TD */
+                {       .input_seg = xhci->event_ring->first_seg,
+                        .start_trb = &xhci->event_ring->first_seg->trbs[3],
+                        .end_trb = &xhci->event_ring->first_seg->trbs[6],
+                        .input_dma = xhci->event_ring->first_seg->dma + 2*16,
+                        .result_seg = NULL,
+                },
+                /* TRB in this ring, but after this wrapped TD */
+                {       .input_seg = xhci->event_ring->first_seg,
+                        .start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3],
+                        .end_trb = &xhci->event_ring->first_seg->trbs[1],
+                        .input_dma = xhci->event_ring->first_seg->dma + 2*16,
+                        .result_seg = NULL,
+                },
+                /* TRB in this ring, but before this wrapped TD */
+                {       .input_seg = xhci->event_ring->first_seg,
+                        .start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3],
+                        .end_trb = &xhci->event_ring->first_seg->trbs[1],
+                        .input_dma = xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 4)*16,
+                        .result_seg = NULL,
+                },
+                /* TRB not in this ring, and we have a wrapped TD */
+                {       .input_seg = xhci->event_ring->first_seg,
+                        .start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3],
+                        .end_trb = &xhci->event_ring->first_seg->trbs[1],
+                        .input_dma = xhci->cmd_ring->first_seg->dma + 2*16,
+                        .result_seg = NULL,
+                },
+        };
+
+        unsigned int num_tests;
+        int i, ret;
+
+        num_tests = sizeof(simple_test_vector) / sizeof(simple_test_vector[0]);
+        for (i = 0; i < num_tests; i++) {
+                ret = xhci_test_trb_in_td(xhci,
+                                xhci->event_ring->first_seg,
+                                xhci->event_ring->first_seg->trbs,
+                                &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1],
+                                simple_test_vector[i].input_dma,
+                                simple_test_vector[i].result_seg,
+                                "Simple", i);
+                if (ret < 0)
+                        return ret;
+        }
+
+        num_tests = sizeof(complex_test_vector) / sizeof(complex_test_vector[0]);
+        for (i = 0; i < num_tests; i++) {
+                ret = xhci_test_trb_in_td(xhci,
+                                complex_test_vector[i].input_seg,
+                                complex_test_vector[i].start_trb,
+                                complex_test_vector[i].end_trb,
+                                complex_test_vector[i].input_dma,
+                                complex_test_vector[i].result_seg,
+                                "Complex", i);
+                if (ret < 0)
+                        return ret;
+        }
+        xhci_dbg(xhci, "TRB math tests passed.\n");
+        return 0;
+}
+
+
 int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
 {
         dma_addr_t      dma;
@@ -951,6 +1274,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags);
         if (!xhci->event_ring)
                 goto fail;
+        if (xhci_check_trb_in_td_math(xhci, flags) < 0)
+                goto fail;
 
         xhci->erst.entries = pci_alloc_consistent(to_pci_dev(dev),
                         sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS, &dma);
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 06595ec27bb7..417d37aff8d7 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -54,6 +54,8 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
         struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
         int                     retval;
 
+        hcd->self.sg_tablesize = TRBS_PER_SEGMENT - 1;
+
         xhci->cap_regs = hcd->regs;
         xhci->op_regs = hcd->regs +
                 HC_LENGTH(xhci_readl(xhci, &xhci->cap_regs->hc_capbase));
@@ -137,6 +139,7 @@ static const struct hc_driver xhci_pci_hc_driver = {
         .reset_bandwidth =      xhci_reset_bandwidth,
         .address_device =       xhci_address_device,
         .update_hub_device =    xhci_update_hub_device,
+        .reset_device =         xhci_reset_device,
 
         /*
          * scheduling support
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 821b7b4709de..85d7e8f2085e 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -65,6 +65,7 @@
  */
 
 #include <linux/scatterlist.h>
+#include <linux/slab.h>
 #include "xhci.h"
 
 /*
@@ -306,7 +307,7 @@ static void ring_ep_doorbell(struct xhci_hcd *xhci,
         /* Don't ring the doorbell for this endpoint if there are pending
          * cancellations because the we don't want to interrupt processing.
          */
-        if (!ep->cancels_pending && !(ep_state & SET_DEQ_PENDING)
+        if (!(ep_state & EP_HALT_PENDING) && !(ep_state & SET_DEQ_PENDING)
                         && !(ep_state & EP_HALTED)) {
                 field = xhci_readl(xhci, db_addr) & DB_MASK;
                 xhci_writel(xhci, field | EPI_TO_DB(ep_index), db_addr);
@@ -475,6 +476,35 @@ void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
         ep->ep_state |= SET_DEQ_PENDING;
 }
 
+static inline void xhci_stop_watchdog_timer_in_irq(struct xhci_hcd *xhci,
+                struct xhci_virt_ep *ep)
+{
+        ep->ep_state &= ~EP_HALT_PENDING;
+        /* Can't del_timer_sync in interrupt, so we attempt to cancel.  If the
+         * timer is running on another CPU, we don't decrement stop_cmds_pending
+         * (since we didn't successfully stop the watchdog timer).
+         */
+        if (del_timer(&ep->stop_cmd_timer))
+                ep->stop_cmds_pending--;
+}
+
+/* Must be called with xhci->lock held in interrupt context */
+static void xhci_giveback_urb_in_irq(struct xhci_hcd *xhci,
+                struct xhci_td *cur_td, int status, char *adjective)
+{
+        struct usb_hcd *hcd = xhci_to_hcd(xhci);
+
+        cur_td->urb->hcpriv = NULL;
+        usb_hcd_unlink_urb_from_ep(hcd, cur_td->urb);
+        xhci_dbg(xhci, "Giveback %s URB %p\n", adjective, cur_td->urb);
+
+        spin_unlock(&xhci->lock);
+        usb_hcd_giveback_urb(hcd, cur_td->urb, status);
+        kfree(cur_td);
+        spin_lock(&xhci->lock);
+        xhci_dbg(xhci, "%s URB given back\n", adjective);
+}
+
 /*
  * When we get a command completion for a Stop Endpoint Command, we need to
  * unlink any cancelled TDs from the ring.  There are two ways to do that:
@@ -497,9 +527,6 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
         struct xhci_td *last_unlinked_td;
 
         struct xhci_dequeue_state deq_state;
-#ifdef CONFIG_USB_HCD_STAT
-        ktime_t stop_time = ktime_get();
-#endif
 
         memset(&deq_state, 0, sizeof(deq_state));
         slot_id = TRB_TO_SLOT_ID(trb->generic.field[3]);
@@ -507,8 +534,11 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
         ep = &xhci->devs[slot_id]->eps[ep_index];
         ep_ring = ep->ring;
 
-        if (list_empty(&ep->cancelled_td_list))
+        if (list_empty(&ep->cancelled_td_list)) {
+                xhci_stop_watchdog_timer_in_irq(xhci, ep);
+                ring_ep_doorbell(xhci, slot_id, ep_index);
                 return;
+        }
 
         /* Fix up the ep ring first, so HW stops executing cancelled TDs.
          * We have the xHCI lock, so nothing can modify this list until we drop
@@ -535,9 +565,9 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
                  * the cancelled TD list for URB completion later.
                  */
                 list_del(&cur_td->td_list);
-                ep->cancels_pending--;
         }
         last_unlinked_td = cur_td;
+        xhci_stop_watchdog_timer_in_irq(xhci, ep);
 
         /* If necessary, queue a Set Transfer Ring Dequeue Pointer command */
         if (deq_state.new_deq_ptr && deq_state.new_deq_seg) {
@@ -561,27 +591,136 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
                 list_del(&cur_td->cancelled_td_list);
 
                 /* Clean up the cancelled URB */
-#ifdef CONFIG_USB_HCD_STAT
-                hcd_stat_update(xhci->tp_stat, cur_td->urb->actual_length,
-                                ktime_sub(stop_time, cur_td->start_time));
-#endif
-                cur_td->urb->hcpriv = NULL;
-                usb_hcd_unlink_urb_from_ep(xhci_to_hcd(xhci), cur_td->urb);
-
-                xhci_dbg(xhci, "Giveback cancelled URB %p\n", cur_td->urb);
-                spin_unlock(&xhci->lock);
                 /* Doesn't matter what we pass for status, since the core will
                  * just overwrite it (because the URB has been unlinked).
                  */
-                usb_hcd_giveback_urb(xhci_to_hcd(xhci), cur_td->urb, 0);
-                kfree(cur_td);
+                xhci_giveback_urb_in_irq(xhci, cur_td, 0, "cancelled");
 
-                spin_lock(&xhci->lock);
+                /* Stop processing the cancelled list if the watchdog timer is
+                 * running.
+                 */
+                if (xhci->xhc_state & XHCI_STATE_DYING)
+                        return;
         } while (cur_td != last_unlinked_td);
 
         /* Return to the event handler with xhci->lock re-acquired */
 }
 
+/* Watchdog timer function for when a stop endpoint command fails to complete.
+ * In this case, we assume the host controller is broken or dying or dead.  The
+ * host may still be completing some other events, so we have to be careful to
+ * let the event ring handler and the URB dequeueing/enqueueing functions know
+ * through xhci->state.
+ *
+ * The timer may also fire if the host takes a very long time to respond to the
+ * command, and the stop endpoint command completion handler cannot delete the
+ * timer before the timer function is called.  Another endpoint cancellation may
+ * sneak in before the timer function can grab the lock, and that may queue
+ * another stop endpoint command and add the timer back.  So we cannot use a
+ * simple flag to say whether there is a pending stop endpoint command for a
+ * particular endpoint.
+ *
+ * Instead we use a combination of that flag and a counter for the number of
+ * pending stop endpoint commands.  If the timer is the tail end of the last
+ * stop endpoint command, and the endpoint's command is still pending, we assume
+ * the host is dying.
+ */
+void xhci_stop_endpoint_command_watchdog(unsigned long arg)
+{
+        struct xhci_hcd *xhci;
+        struct xhci_virt_ep *ep;
+        struct xhci_virt_ep *temp_ep;
+        struct xhci_ring *ring;
+        struct xhci_td *cur_td;
+        int ret, i, j;
+
+        ep = (struct xhci_virt_ep *) arg;
+        xhci = ep->xhci;
+
+        spin_lock(&xhci->lock);
+
+        ep->stop_cmds_pending--;
+        if (xhci->xhc_state & XHCI_STATE_DYING) {
+                xhci_dbg(xhci, "Stop EP timer ran, but another timer marked "
+                                "xHCI as DYING, exiting.\n");
+                spin_unlock(&xhci->lock);
+                return;
+        }
+        if (!(ep->stop_cmds_pending == 0 && (ep->ep_state & EP_HALT_PENDING))) {
+                xhci_dbg(xhci, "Stop EP timer ran, but no command pending, "
+                                "exiting.\n");
+                spin_unlock(&xhci->lock);
+                return;
+        }
+
+        xhci_warn(xhci, "xHCI host not responding to stop endpoint command.\n");
+        xhci_warn(xhci, "Assuming host is dying, halting host.\n");
+        /* Oops, HC is dead or dying or at least not responding to the stop
+         * endpoint command.
+         */
+        xhci->xhc_state |= XHCI_STATE_DYING;
+        /* Disable interrupts from the host controller and start halting it */
+        xhci_quiesce(xhci);
+        spin_unlock(&xhci->lock);
+
+        ret = xhci_halt(xhci);
+
+        spin_lock(&xhci->lock);
+        if (ret < 0) {
+                /* This is bad; the host is not responding to commands and it's
+                 * not allowing itself to be halted.  At least interrupts are
+                 * disabled, so we can set HC_STATE_HALT and notify the
+                 * USB core.  But if we call usb_hc_died(), it will attempt to
+                 * disconnect all device drivers under this host.  Those
+                 * disconnect() methods will wait for all URBs to be unlinked,
+                 * so we must complete them.
+                 */
+                xhci_warn(xhci, "Non-responsive xHCI host is not halting.\n");
+                xhci_warn(xhci, "Completing active URBs anyway.\n");
+                /* We could turn all TDs on the rings to no-ops.  This won't
+                 * help if the host has cached part of the ring, and is slow if
+                 * we want to preserve the cycle bit.  Skip it and hope the host
+                 * doesn't touch the memory.
+                 */
+        }
+        for (i = 0; i < MAX_HC_SLOTS; i++) {
+                if (!xhci->devs[i])
+                        continue;
+                for (j = 0; j < 31; j++) {
+                        temp_ep = &xhci->devs[i]->eps[j];
+                        ring = temp_ep->ring;
+                        if (!ring)
+                                continue;
+                        xhci_dbg(xhci, "Killing URBs for slot ID %u, "
+                                        "ep index %u\n", i, j);
+                        while (!list_empty(&ring->td_list)) {
+                                cur_td = list_first_entry(&ring->td_list,
+                                                struct xhci_td,
+                                                td_list);
+                                list_del(&cur_td->td_list);
+                                if (!list_empty(&cur_td->cancelled_td_list))
+                                        list_del(&cur_td->cancelled_td_list);
+                                xhci_giveback_urb_in_irq(xhci, cur_td,
+                                                -ESHUTDOWN, "killed");
+                        }
+                        while (!list_empty(&temp_ep->cancelled_td_list)) {
+                                cur_td = list_first_entry(
+                                                &temp_ep->cancelled_td_list,
+                                                struct xhci_td,
+                                                cancelled_td_list);
+                                list_del(&cur_td->cancelled_td_list);
+                                xhci_giveback_urb_in_irq(xhci, cur_td,
+                                                -ESHUTDOWN, "killed");
+                        }
+                }
+        }
+        spin_unlock(&xhci->lock);
+        xhci_to_hcd(xhci)->state = HC_STATE_HALT;
+        xhci_dbg(xhci, "Calling usb_hc_died()\n");
+        usb_hc_died(xhci_to_hcd(xhci));
+        xhci_dbg(xhci, "xHCI host controller is dead.\n");
+}
+
 /*
  * When we get a completion for a Set Transfer Ring Dequeue Pointer command,
  * we need to clear the set deq pending flag in the endpoint ring state, so that
@@ -765,28 +904,32 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                                 virt_dev->in_ctx);
                 /* Input ctx add_flags are the endpoint index plus one */
                 ep_index = xhci_last_valid_endpoint(ctrl_ctx->add_flags) - 1;
-                ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
-                if (!ep_ring) {
-                        /* This must have been an initial configure endpoint */
-                        xhci->devs[slot_id]->cmd_status =
-                                GET_COMP_CODE(event->status);
-                        complete(&xhci->devs[slot_id]->cmd_completion);
-                        break;
-                }
-                ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;
-                xhci_dbg(xhci, "Completed config ep cmd - last ep index = %d, "
-                                "state = %d\n", ep_index, ep_state);
+                /* A usb_set_interface() call directly after clearing a halted
+                 * condition may race on this quirky hardware.
+                 * Not worth worrying about, since this is prototype hardware.
+                 */
                 if (xhci->quirks & XHCI_RESET_EP_QUIRK &&
-                                ep_state & EP_HALTED) {
+                                ep_index != (unsigned int) -1 &&
+                                ctrl_ctx->add_flags - SLOT_FLAG ==
+                                        ctrl_ctx->drop_flags) {
+                        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
+                        ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;
+                        if (!(ep_state & EP_HALTED))
+                                goto bandwidth_change;
+                        xhci_dbg(xhci, "Completed config ep cmd - "
+                                        "last ep index = %d, state = %d\n",
+                                        ep_index, ep_state);
                         /* Clear our internal halted state and restart ring */
                         xhci->devs[slot_id]->eps[ep_index].ep_state &=
                                 ~EP_HALTED;
                         ring_ep_doorbell(xhci, slot_id, ep_index);
-                } else {
-                        xhci->devs[slot_id]->cmd_status =
-                                GET_COMP_CODE(event->status);
-                        complete(&xhci->devs[slot_id]->cmd_completion);
+                        break;
                 }
+bandwidth_change:
+                xhci_dbg(xhci, "Completed config ep cmd\n");
+                xhci->devs[slot_id]->cmd_status =
+                        GET_COMP_CODE(event->status);
+                complete(&xhci->devs[slot_id]->cmd_completion);
                 break;
         case TRB_TYPE(TRB_EVAL_CONTEXT):
                 virt_dev = xhci->devs[slot_id];
@@ -811,6 +954,17 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
         case TRB_TYPE(TRB_RESET_EP):
                 handle_reset_ep_completion(xhci, event, xhci->cmd_ring->dequeue);
                 break;
+        case TRB_TYPE(TRB_RESET_DEV):
+                xhci_dbg(xhci, "Completed reset device command.\n");
+                slot_id = TRB_TO_SLOT_ID(
+                                xhci->cmd_ring->dequeue->generic.field[3]);
+                virt_dev = xhci->devs[slot_id];
+                if (virt_dev)
+                        handle_cmd_in_cmd_wait_list(xhci, virt_dev, event);
+                else
+                        xhci_warn(xhci, "Reset device command completion "
+                                        "for disabled slot %u\n", slot_id);
+                break;
         default:
                 /* Skip over unknown commands on the event ring */
                 xhci->error_bitmask |= 1 << 6;
@@ -849,8 +1003,7 @@ static void handle_port_status(struct xhci_hcd *xhci,
  * TRB in this TD, this function returns that TRB's segment.  Otherwise it
  * returns 0.
  */
-static struct xhci_segment *trb_in_td(
-                struct xhci_segment *start_seg,
+struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
                 union xhci_trb  *start_trb,
                 union xhci_trb  *end_trb,
                 dma_addr_t      suspect_dma)
@@ -900,6 +1053,59 @@ static struct xhci_segment *trb_in_td(
         return 0;
 }
 
+static void xhci_cleanup_halted_endpoint(struct xhci_hcd *xhci,
+                unsigned int slot_id, unsigned int ep_index,
+                struct xhci_td *td, union xhci_trb *event_trb)
+{
+        struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
+        ep->ep_state |= EP_HALTED;
+        ep->stopped_td = td;
+        ep->stopped_trb = event_trb;
+        xhci_queue_reset_ep(xhci, slot_id, ep_index);
+        xhci_cleanup_stalled_ring(xhci, td->urb->dev, ep_index);
+        xhci_ring_cmd_db(xhci);
+}
+
+/* Check if an error has halted the endpoint ring.  The class driver will
+ * cleanup the halt for a non-default control endpoint if we indicate a stall.
+ * However, a babble and other errors also halt the endpoint ring, and the class
+ * driver won't clear the halt in that case, so we need to issue a Set Transfer
+ * Ring Dequeue Pointer command manually.
+ */
+static int xhci_requires_manual_halt_cleanup(struct xhci_hcd *xhci,
+                struct xhci_ep_ctx *ep_ctx,
+                unsigned int trb_comp_code)
+{
+        /* TRB completion codes that may require a manual halt cleanup */
+        if (trb_comp_code == COMP_TX_ERR ||
+                        trb_comp_code == COMP_BABBLE ||
+                        trb_comp_code == COMP_SPLIT_ERR)
+                /* The 0.96 spec says a babbling control endpoint
+                 * is not halted. The 0.96 spec says it is.  Some HW
+                 * claims to be 0.95 compliant, but it halts the control
+                 * endpoint anyway.  Check if a babble halted the
+                 * endpoint.
+                 */
+                if ((ep_ctx->ep_info & EP_STATE_MASK) == EP_STATE_HALTED)
+                        return 1;
+
+        return 0;
+}
+
+int xhci_is_vendor_info_code(struct xhci_hcd *xhci, unsigned int trb_comp_code)
+{
+        if (trb_comp_code >= 224 && trb_comp_code <= 255) {
+                /* Vendor defined "informational" completion code,
+                 * treat as not-an-error.
+                 */
+                xhci_dbg(xhci, "Vendor defined info completion code %u\n",
+                                trb_comp_code);
+                xhci_dbg(xhci, "Treating code as success.\n");
+                return 1;
+        }
+        return 0;
+}
+
 /*
  * If this function returns an error condition, it means it got a Transfer
  * event with a corrupted Slot ID, Endpoint ID, or TRB DMA address.
@@ -1002,6 +1208,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 xhci_warn(xhci, "WARN: TRB error on endpoint\n");
                 status = -EILSEQ;
                 break;
+        case COMP_SPLIT_ERR:
         case COMP_TX_ERR:
                 xhci_warn(xhci, "WARN: transfer error on endpoint\n");
                 status = -EPROTO;
@@ -1015,6 +1222,10 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 status = -ENOSR;
                 break;
         default:
+                if (xhci_is_vendor_info_code(xhci, trb_comp_code)) {
+                        status = 0;
+                        break;
+                }
                 xhci_warn(xhci, "ERROR Unknown event condition, HC probably busted\n");
                 urb = NULL;
                 goto cleanup;
@@ -1043,15 +1254,14 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         else
                                 status = 0;
                         break;
-                case COMP_BABBLE:
-                        /* The 0.96 spec says a babbling control endpoint
-                         * is not halted. The 0.96 spec says it is.  Some HW
-                         * claims to be 0.95 compliant, but it halts the control
-                         * endpoint anyway.  Check if a babble halted the
-                         * endpoint.
-                         */
-                        if (ep_ctx->ep_info != EP_STATE_HALTED)
+
+                default:
+                        if (!xhci_requires_manual_halt_cleanup(xhci,
+                                                ep_ctx, trb_comp_code))
                                 break;
+                        xhci_dbg(xhci, "TRB error code %u, "
+                                        "halted endpoint index = %u\n",
+                                        trb_comp_code, ep_index);
                         /* else fall through */
                 case COMP_STALL:
                         /* Did we transfer part of the data (middle) phase? */
@@ -1063,15 +1273,9 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         else
                                 td->urb->actual_length = 0;
 
-                        ep->stopped_td = td;
-                        ep->stopped_trb = event_trb;
-                        xhci_queue_reset_ep(xhci, slot_id, ep_index);
-                        xhci_cleanup_stalled_ring(xhci, td->urb->dev, ep_index);
-                        xhci_ring_cmd_db(xhci);
+                        xhci_cleanup_halted_endpoint(xhci,
+                                        slot_id, ep_index, td, event_trb);
                         goto td_cleanup;
-                default:
-                        /* Others already handled above */
-                        break;
                 }
                 /*
                  * Did we transfer any data, despite the errors that might have
@@ -1209,16 +1413,25 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 ep->stopped_td = td;
                 ep->stopped_trb = event_trb;
         } else {
-                if (trb_comp_code == COMP_STALL ||
-                                trb_comp_code == COMP_BABBLE) {
+                if (trb_comp_code == COMP_STALL) {
                         /* The transfer is completed from the driver's
                          * perspective, but we need to issue a set dequeue
                          * command for this stalled endpoint to move the dequeue
                          * pointer past the TD.  We can't do that here because
-                         * the halt condition must be cleared first.
+                         * the halt condition must be cleared first.  Let the
+                         * USB class driver clear the stall later.
                          */
                         ep->stopped_td = td;
                         ep->stopped_trb = event_trb;
+                } else if (xhci_requires_manual_halt_cleanup(xhci,
+                                        ep_ctx, trb_comp_code)) {
+                        /* Other types of errors halt the endpoint, but the
+                         * class driver doesn't call usb_reset_endpoint() unless
+                         * the error is -EPIPE.  Clear the halted status in the
+                         * xHCI hardware manually.
+                         */
+                        xhci_cleanup_halted_endpoint(xhci,
+                                        slot_id, ep_index, td, event_trb);
                 } else {
                         /* Update ring dequeue pointer */
                         while (ep_ring->dequeue != td->last_trb)
@@ -1249,10 +1462,9 @@ td_cleanup:
                 }
                 list_del(&td->td_list);
                 /* Was this TD slated to be cancelled but completed anyway? */
-                if (!list_empty(&td->cancelled_td_list)) {
+                if (!list_empty(&td->cancelled_td_list))
                         list_del(&td->cancelled_td_list);
-                        ep->cancels_pending--;
-                }
+
                 /* Leave the TD around for the reset endpoint function to use
                  * (but only if it's not a control endpoint, since we already
                  * queued the Set TR dequeue pointer command for stalled
@@ -1331,6 +1543,14 @@ void xhci_handle_event(struct xhci_hcd *xhci)
         default:
                 xhci->error_bitmask |= 1 << 3;
         }
+        /* Any of the above functions may drop and re-acquire the lock, so check
+         * to make sure a watchdog timer didn't mark the host as non-responsive.
+         */
+        if (xhci->xhc_state & XHCI_STATE_DYING) {
+                xhci_dbg(xhci, "xHCI host dying, returning from "
+                                "event handler.\n");
+                return;
+        }
 
         if (update_ptrs) {
                 /* Update SW and HC event ring dequeue pointer */
@@ -1555,6 +1775,21 @@ int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         return xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb, slot_id, ep_index);
 }
 
+/*
+ * The TD size is the number of bytes remaining in the TD (including this TRB),
+ * right shifted by 10.
+ * It must fit in bits 21:17, so it can't be bigger than 31.
+ */
+static u32 xhci_td_remainder(unsigned int remainder)
+{
+        u32 max = (1 << (21 - 17 + 1)) - 1;
+
+        if ((remainder >> 10) >= max)
+                return max << 17;
+        else
+                return (remainder >> 10) << 17;
+}
+
 static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 struct urb *urb, int slot_id, unsigned int ep_index)
 {
@@ -1612,6 +1847,7 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         do {
                 u32 field = 0;
                 u32 length_field = 0;
+                u32 remainder = 0;
 
                 /* Don't change the cycle bit of the first TRB until later */
                 if (first_trb)
@@ -1641,8 +1877,10 @@ static int queue_bulk_sg_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                         (unsigned int) (addr + TRB_MAX_BUFF_SIZE) & ~(TRB_MAX_BUFF_SIZE - 1),
                                         (unsigned int) addr + trb_buff_len);
                 }
+                remainder = xhci_td_remainder(urb->transfer_buffer_length -
+                                running_total) ;
                 length_field = TRB_LEN(trb_buff_len) |
-                        TD_REMAINDER(urb->transfer_buffer_length - running_total) |
+                        remainder |
                         TRB_INTR_TARGET(0);
                 queue_trb(xhci, ep_ring, false,
                                 lower_32_bits(addr),
@@ -1755,6 +1993,7 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
         /* Queue the first TRB, even if it's zero-length */
         do {
+                u32 remainder = 0;
                 field = 0;
 
                 /* Don't change the cycle bit of the first TRB until later */
@@ -1773,8 +2012,10 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         td->last_trb = ep_ring->enqueue;
                         field |= TRB_IOC;
                 }
+                remainder = xhci_td_remainder(urb->transfer_buffer_length -
+                                running_total);
                 length_field = TRB_LEN(trb_buff_len) |
-                        TD_REMAINDER(urb->transfer_buffer_length - running_total) |
+                        remainder |
                         TRB_INTR_TARGET(0);
                 queue_trb(xhci, ep_ring, false,
                                 lower_32_bits(addr),
@@ -1862,7 +2103,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         /* If there's data, queue data TRBs */
         field = 0;
         length_field = TRB_LEN(urb->transfer_buffer_length) |
-                TD_REMAINDER(urb->transfer_buffer_length) |
+                xhci_td_remainder(urb->transfer_buffer_length) |
                 TRB_INTR_TARGET(0);
         if (urb->transfer_buffer_length > 0) {
                 if (setup->bRequestType & USB_DIR_IN)
@@ -1960,6 +2201,14 @@ int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
                         false);
 }
 
+/* Queue a reset device command TRB */
+int xhci_queue_reset_device(struct xhci_hcd *xhci, u32 slot_id)
+{
+        return queue_command(xhci, 0, 0, 0,
+                        TRB_TYPE(TRB_RESET_DEV) | SLOT_ID_FOR_TRB(slot_id),
+                        false);
+}
+
 /* Queue a configure endpoint command TRB */
 int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
                 u32 slot_id, bool command_must_succeed)
diff --git a/drivers/usb/host/xhci-hcd.c b/drivers/usb/host/xhci.c
index 932f99938481..7e4277273908 100644
--- a/drivers/usb/host/xhci-hcd.c
+++ b/drivers/usb/host/xhci.c
@@ -23,6 +23,7 @@
 #include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 
 #include "xhci.h"
 
@@ -67,22 +68,14 @@ static int handshake(struct xhci_hcd *xhci, void __iomem *ptr,
 }
 
 /*
- * Force HC into halt state.
- *
- * Disable any IRQs and clear the run/stop bit.
- * HC will complete any current and actively pipelined transactions, and
- * should halt within 16 microframes of the run/stop bit being cleared.
- * Read HC Halted bit in the status register to see when the HC is finished.
- * XXX: shouldn't we set HC_STATE_HALT here somewhere?
+ * Disable interrupts and begin the xHCI halting process.
  */
-int xhci_halt(struct xhci_hcd *xhci)
+void xhci_quiesce(struct xhci_hcd *xhci)
 {
         u32 halted;
         u32 cmd;
         u32 mask;
 
-        xhci_dbg(xhci, "// Halt the HC\n");
-        /* Disable all interrupts from the host controller */
         mask = ~(XHCI_IRQS);
         halted = xhci_readl(xhci, &xhci->op_regs->status) & STS_HALT;
         if (!halted)
@@ -91,6 +84,21 @@ int xhci_halt(struct xhci_hcd *xhci)
         cmd = xhci_readl(xhci, &xhci->op_regs->command);
         cmd &= mask;
         xhci_writel(xhci, cmd, &xhci->op_regs->command);
+}
+
+/*
+ * Force HC into halt state.
+ *
+ * Disable any IRQs and clear the run/stop bit.
+ * HC will complete any current and actively pipelined transactions, and
+ * should halt within 16 microframes of the run/stop bit being cleared.
+ * Read HC Halted bit in the status register to see when the HC is finished.
+ * XXX: shouldn't we set HC_STATE_HALT here somewhere?
+ */
+int xhci_halt(struct xhci_hcd *xhci)
+{
+        xhci_dbg(xhci, "// Halt the HC\n");
+        xhci_quiesce(xhci);
 
         return handshake(xhci, &xhci->op_regs->status,
                         STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC);
@@ -124,28 +132,6 @@ int xhci_reset(struct xhci_hcd *xhci)
         return handshake(xhci, &xhci->op_regs->command, CMD_RESET, 0, 250 * 1000);
 }
 
-/*
- * Stop the HC from processing the endpoint queues.
- */
-static void xhci_quiesce(struct xhci_hcd *xhci)
-{
-        /*
-         * Queues are per endpoint, so we need to disable an endpoint or slot.
-         *
-         * To disable a slot, we need to insert a disable slot command on the
-         * command ring and ring the doorbell.  This will also free any internal
-         * resources associated with the slot (which might not be what we want).
-         *
-         * A Release Endpoint command sounds better - doesn't free internal HC
-         * memory, but removes the endpoints from the schedule and releases the
-         * bandwidth, disables the doorbells, and clears the endpoint enable
-         * flag.  Usually used prior to a set interface command.
-         *
-         * TODO: Implement after command ring code is done.
-         */
-        BUG_ON(!HC_IS_RUNNING(xhci_to_hcd(xhci)->state));
-        xhci_dbg(xhci, "Finished quiescing -- code not written yet\n");
-}
 
 #if 0
 /* Set up MSI-X table for entry 0 (may claim other entries later) */
@@ -261,8 +247,14 @@ static void xhci_work(struct xhci_hcd *xhci)
         /* Flush posted writes */
         xhci_readl(xhci, &xhci->ir_set->irq_pending);
 
-        /* FIXME this should be a delayed service routine that clears the EHB */
-        xhci_handle_event(xhci);
+        if (xhci->xhc_state & XHCI_STATE_DYING)
+                xhci_dbg(xhci, "xHCI dying, ignoring interrupt. "
+                                "Shouldn't IRQs be disabled?\n");
+        else
+                /* FIXME this should be a delayed service routine
+                 * that clears the EHB.
+                 */
+                xhci_handle_event(xhci);
 
         /* Clear the event handler busy flag (RW1C); the event ring should be empty. */
         temp_64 = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
@@ -335,7 +327,7 @@ void xhci_event_ring_work(unsigned long arg)
         spin_lock_irqsave(&xhci->lock, flags);
         temp = xhci_readl(xhci, &xhci->op_regs->status);
         xhci_dbg(xhci, "op reg status = 0x%x\n", temp);
-        if (temp == 0xffffffff) {
+        if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
                 xhci_dbg(xhci, "HW died, polling stopped.\n");
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 return;
@@ -490,8 +482,6 @@ void xhci_stop(struct usb_hcd *hcd)
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 
         spin_lock_irq(&xhci->lock);
-        if (HC_IS_RUNNING(hcd->state))
-                xhci_quiesce(xhci);
         xhci_halt(xhci);
         xhci_reset(xhci);
         spin_unlock_irq(&xhci->lock);
@@ -727,16 +717,22 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                  * atomic context to this function, which may allocate memory.
                  */
                 spin_lock_irqsave(&xhci->lock, flags);
+                if (xhci->xhc_state & XHCI_STATE_DYING)
+                        goto dying;
                 ret = xhci_queue_ctrl_tx(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
                 spin_unlock_irqrestore(&xhci->lock, flags);
         } else if (usb_endpoint_xfer_bulk(&urb->ep->desc)) {
                 spin_lock_irqsave(&xhci->lock, flags);
+                if (xhci->xhc_state & XHCI_STATE_DYING)
+                        goto dying;
                 ret = xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
                 spin_unlock_irqrestore(&xhci->lock, flags);
         } else if (usb_endpoint_xfer_int(&urb->ep->desc)) {
                 spin_lock_irqsave(&xhci->lock, flags);
+                if (xhci->xhc_state & XHCI_STATE_DYING)
+                        goto dying;
                 ret = xhci_queue_intr_tx(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
                 spin_unlock_irqrestore(&xhci->lock, flags);
@@ -745,6 +741,12 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
         }
 exit:
         return ret;
+dying:
+        xhci_dbg(xhci, "Ep 0x%x: URB %p submitted for "
+                        "non-responsive xHCI host.\n",
+                        urb->ep->desc.bEndpointAddress, urb);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return -ESHUTDOWN;
 }
 
 /*
@@ -806,6 +808,17 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                 kfree(td);
                 return ret;
         }
+        if (xhci->xhc_state & XHCI_STATE_DYING) {
+                xhci_dbg(xhci, "Ep 0x%x: URB %p to be canceled on "
+                                "non-responsive xHCI host.\n",
+                                urb->ep->desc.bEndpointAddress, urb);
+                /* Let the stop endpoint command watchdog timer (which set this
+                 * state) finish cleaning up the endpoint TD lists.  We must
+                 * have caught it in the middle of dropping a lock and giving
+                 * back an URB.
+                 */
+                goto done;
+        }
 
         xhci_dbg(xhci, "Cancel URB %p\n", urb);
         xhci_dbg(xhci, "Event ring:\n");
@@ -817,12 +830,16 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         xhci_debug_ring(xhci, ep_ring);
         td = (struct xhci_td *) urb->hcpriv;
 
-        ep->cancels_pending++;
         list_add_tail(&td->cancelled_td_list, &ep->cancelled_td_list);
         /* Queue a stop endpoint command, but only if this is
          * the first cancellation to be handled.
          */
-        if (ep->cancels_pending == 1) {
+        if (!(ep->ep_state & EP_HALT_PENDING)) {
+                ep->ep_state |= EP_HALT_PENDING;
+                ep->stop_cmds_pending++;
+                ep->stop_cmd_timer.expires = jiffies +
+                        XHCI_STOP_EP_CMD_TIMEOUT * HZ;
+                add_timer(&ep->stop_cmd_timer);
                 xhci_queue_stop_endpoint(xhci, urb->dev->slot_id, ep_index);
                 xhci_ring_cmd_db(xhci);
         }
@@ -991,7 +1008,7 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
          * for usb_set_interface() and usb_set_configuration() claim).
          */
         if (xhci_endpoint_init(xhci, xhci->devs[udev->slot_id],
-                                udev, ep, GFP_KERNEL) < 0) {
+                                udev, ep, GFP_NOIO) < 0) {
                 dev_dbg(&udev->dev, "%s - could not initialize ep %#x\n",
                                 __func__, ep->desc.bEndpointAddress);
                 return -ENOMEM;
@@ -1157,6 +1174,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 cmd_completion = &virt_dev->cmd_completion;
                 cmd_status = &virt_dev->cmd_status;
         }
+        init_completion(cmd_completion);
 
         if (!ctx_change)
                 ret = xhci_queue_configure_endpoint(xhci, in_ctx->dma,
@@ -1165,6 +1183,8 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 ret = xhci_queue_evaluate_context(xhci, in_ctx->dma,
                                 udev->slot_id);
         if (ret < 0) {
+                if (command)
+                        list_del(&command->cmd_list);
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg(xhci, "FIXME allocate a new ring segment\n");
                 return -ENOMEM;
@@ -1246,13 +1266,18 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
                         LAST_CTX_TO_EP_NUM(slot_ctx->dev_info));
 
         xhci_zero_in_ctx(xhci, virt_dev);
-        /* Free any old rings */
+        /* Install new rings and free or cache any old rings */
         for (i = 1; i < 31; ++i) {
-                if (virt_dev->eps[i].new_ring) {
-                        xhci_ring_free(xhci, virt_dev->eps[i].ring);
-                        virt_dev->eps[i].ring = virt_dev->eps[i].new_ring;
-                        virt_dev->eps[i].new_ring = NULL;
+                if (!virt_dev->eps[i].new_ring)
+                        continue;
+                /* Only cache or free the old ring if it exists.
+                 * It may not if this is the first add of an endpoint.
+                 */
+                if (virt_dev->eps[i].ring) {
+                        xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
                 }
+                virt_dev->eps[i].ring = virt_dev->eps[i].new_ring;
+                virt_dev->eps[i].new_ring = NULL;
         }
 
         return ret;
@@ -1420,6 +1445,131 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
 }
 
 /*
+ * This submits a Reset Device Command, which will set the device state to 0,
+ * set the device address to 0, and disable all the endpoints except the default
+ * control endpoint.  The USB core should come back and call
+ * xhci_address_device(), and then re-set up the configuration.  If this is
+ * called because of a usb_reset_and_verify_device(), then the old alternate
+ * settings will be re-installed through the normal bandwidth allocation
+ * functions.
+ *
+ * Wait for the Reset Device command to finish.  Remove all structures
+ * associated with the endpoints that were disabled.  Clear the input device
+ * structure?  Cache the rings?  Reset the control endpoint 0 max packet size?
+ */
+int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
+{
+        int ret, i;
+        unsigned long flags;
+        struct xhci_hcd *xhci;
+        unsigned int slot_id;
+        struct xhci_virt_device *virt_dev;
+        struct xhci_command *reset_device_cmd;
+        int timeleft;
+        int last_freed_endpoint;
+
+        ret = xhci_check_args(hcd, udev, NULL, 0, __func__);
+        if (ret <= 0)
+                return ret;
+        xhci = hcd_to_xhci(hcd);
+        slot_id = udev->slot_id;
+        virt_dev = xhci->devs[slot_id];
+        if (!virt_dev) {
+                xhci_dbg(xhci, "%s called with invalid slot ID %u\n",
+                                __func__, slot_id);
+                return -EINVAL;
+        }
+
+        xhci_dbg(xhci, "Resetting device with slot ID %u\n", slot_id);
+        /* Allocate the command structure that holds the struct completion.
+         * Assume we're in process context, since the normal device reset
+         * process has to wait for the device anyway.  Storage devices are
+         * reset as part of error handling, so use GFP_NOIO instead of
+         * GFP_KERNEL.
+         */
+        reset_device_cmd = xhci_alloc_command(xhci, false, true, GFP_NOIO);
+        if (!reset_device_cmd) {
+                xhci_dbg(xhci, "Couldn't allocate command structure.\n");
+                return -ENOMEM;
+        }
+
+        /* Attempt to submit the Reset Device command to the command ring */
+        spin_lock_irqsave(&xhci->lock, flags);
+        reset_device_cmd->command_trb = xhci->cmd_ring->enqueue;
+        list_add_tail(&reset_device_cmd->cmd_list, &virt_dev->cmd_list);
+        ret = xhci_queue_reset_device(xhci, slot_id);
+        if (ret) {
+                xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
+                list_del(&reset_device_cmd->cmd_list);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                goto command_cleanup;
+        }
+        xhci_ring_cmd_db(xhci);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+
+        /* Wait for the Reset Device command to finish */
+        timeleft = wait_for_completion_interruptible_timeout(
+                        reset_device_cmd->completion,
+                        USB_CTRL_SET_TIMEOUT);
+        if (timeleft <= 0) {
+                xhci_warn(xhci, "%s while waiting for reset device command\n",
+                                timeleft == 0 ? "Timeout" : "Signal");
+                spin_lock_irqsave(&xhci->lock, flags);
+                /* The timeout might have raced with the event ring handler, so
+                 * only delete from the list if the item isn't poisoned.
+                 */
+                if (reset_device_cmd->cmd_list.next != LIST_POISON1)
+                        list_del(&reset_device_cmd->cmd_list);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                ret = -ETIME;
+                goto command_cleanup;
+        }
+
+        /* The Reset Device command can't fail, according to the 0.95/0.96 spec,
+         * unless we tried to reset a slot ID that wasn't enabled,
+         * or the device wasn't in the addressed or configured state.
+         */
+        ret = reset_device_cmd->status;
+        switch (ret) {
+        case COMP_EBADSLT: /* 0.95 completion code for bad slot ID */
+        case COMP_CTX_STATE: /* 0.96 completion code for same thing */
+                xhci_info(xhci, "Can't reset device (slot ID %u) in %s state\n",
+                                slot_id,
+                                xhci_get_slot_state(xhci, virt_dev->out_ctx));
+                xhci_info(xhci, "Not freeing device rings.\n");
+                /* Don't treat this as an error.  May change my mind later. */
+                ret = 0;
+                goto command_cleanup;
+        case COMP_SUCCESS:
+                xhci_dbg(xhci, "Successful reset device command.\n");
+                break;
+        default:
+                if (xhci_is_vendor_info_code(xhci, ret))
+                        break;
+                xhci_warn(xhci, "Unknown completion code %u for "
+                                "reset device command.\n", ret);
+                ret = -EINVAL;
+                goto command_cleanup;
+        }
+
+        /* Everything but endpoint 0 is disabled, so free or cache the rings. */
+        last_freed_endpoint = 1;
+        for (i = 1; i < 31; ++i) {
+                if (!virt_dev->eps[i].ring)
+                        continue;
+                xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
+                last_freed_endpoint = i;
+        }
+        xhci_dbg(xhci, "Output context after successful reset device cmd:\n");
+        xhci_dbg_ctx(xhci, virt_dev->out_ctx, last_freed_endpoint);
+        ret = 0;
+
+command_cleanup:
+        xhci_free_command(xhci, reset_device_cmd);
+        return ret;
+}
+
+/*
  * At this point, the struct usb_device is about to go away, the device has
  * disconnected, and all traffic has been stopped and the endpoints have been
  * disabled.  Free any HC data structures associated with that device.
@@ -1427,16 +1577,27 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
 void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        struct xhci_virt_device *virt_dev;
         unsigned long flags;
         u32 state;
+        int i;
 
         if (udev->slot_id == 0)
                 return;
+        virt_dev = xhci->devs[udev->slot_id];
+        if (!virt_dev)
+                return;
+
+        /* Stop any wayward timer functions (which may grab the lock) */
+        for (i = 0; i < 31; ++i) {
+                virt_dev->eps[i].ep_state &= ~EP_HALT_PENDING;
+                del_timer_sync(&virt_dev->eps[i].stop_cmd_timer);
+        }
 
         spin_lock_irqsave(&xhci->lock, flags);
         /* Don't disable the slot if the host controller is dead. */
         state = xhci_readl(xhci, &xhci->op_regs->status);
-        if (state == 0xffffffff) {
+        if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
                 xhci_free_virt_device(xhci, udev->slot_id);
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 return;
@@ -1645,7 +1806,7 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
                 xhci_warn(xhci, "Cannot update hub desc for unknown device.\n");
                 return -EINVAL;
         }
-        config_cmd = xhci_alloc_command(xhci, true, mem_flags);
+        config_cmd = xhci_alloc_command(xhci, true, true, mem_flags);
         if (!config_cmd) {
                 xhci_dbg(xhci, "Could not allocate xHCI command structure.\n");
                 return -ENOMEM;
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 4b254b6fa245..ea389e9a4931 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -609,6 +609,10 @@ struct xhci_ep_ctx {
 #define MAX_PACKET_MASK         (0xffff << 16)
 #define MAX_PACKET_DECODED(p)   (((p) >> 16) & 0xffff)
 
+/* tx_info bitmasks */
+#define AVG_TRB_LENGTH_FOR_EP(p)        ((p) & 0xffff)
+#define MAX_ESIT_PAYLOAD_FOR_EP(p)      (((p) & 0xffff) << 16)
+
 
 /**
  * struct xhci_input_control_context
@@ -652,13 +656,17 @@ struct xhci_virt_ep {
         struct xhci_ring                *new_ring;
         unsigned int                    ep_state;
 #define SET_DEQ_PENDING         (1 << 0)
-#define EP_HALTED               (1 << 1)
+#define EP_HALTED               (1 << 1)        /* For stall handling */
+#define EP_HALT_PENDING         (1 << 2)        /* For URB cancellation */
         /* ----  Related to URB cancellation ---- */
         struct list_head        cancelled_td_list;
-        unsigned int            cancels_pending;
         /* The TRB that was last reported in a stopped endpoint ring */
         union xhci_trb          *stopped_trb;
         struct xhci_td          *stopped_td;
+        /* Watchdog timer for stop endpoint command to cancel URBs */
+        struct timer_list       stop_cmd_timer;
+        int                     stop_cmds_pending;
+        struct xhci_hcd         *xhci;
 };
 
 struct xhci_virt_device {
@@ -673,6 +681,10 @@ struct xhci_virt_device {
         struct xhci_container_ctx       *out_ctx;
         /* Used for addressing devices and configuration changes */
         struct xhci_container_ctx       *in_ctx;
+        /* Rings saved to ensure old alt settings can be re-instated */
+        struct xhci_ring                **ring_cache;
+        int                             num_rings_cached;
+#define XHCI_MAX_RINGS_CACHED   31
         struct xhci_virt_ep             eps[31];
         struct completion               cmd_completion;
         /* Status of the last command issued for this device */
@@ -824,9 +836,6 @@ struct xhci_event_cmd {
 /* Normal TRB fields */
 /* transfer_len bitmasks - bits 0:16 */
 #define TRB_LEN(p)              ((p) & 0x1ffff)
-/* TD size - number of bytes remaining in the TD (including this TRB):
- * bits 17 - 21.  Shift the number of bytes by 10. */
-#define TD_REMAINDER(p)         ((((p) >> 10) & 0x1f) << 17)
 /* Interrupter Target - which MSI-X vector to target the completion event at */
 #define TRB_INTR_TARGET(p)      (((p) & 0x3ff) << 22)
 #define GET_INTR_TARGET(p)      (((p) >> 22) & 0x3ff)
@@ -1022,6 +1031,8 @@ struct xhci_scratchpad {
 #define ERST_ENTRIES    1
 /* Poll every 60 seconds */
 #define POLL_TIMEOUT    60
+/* Stop endpoint command timeout (secs) for URB cancellation watchdog timer */
+#define XHCI_STOP_EP_CMD_TIMEOUT        5
 /* XXX: Make these module parameters */
 
 
@@ -1083,6 +1094,21 @@ struct xhci_hcd {
         struct timer_list       event_ring_timer;
         int                     zombie;
 #endif
+        /* Host controller watchdog timer structures */
+        unsigned int            xhc_state;
+/* Host controller is dying - not responding to commands. "I'm not dead yet!"
+ *
+ * xHC interrupts have been disabled and a watchdog timer will (or has already)
+ * halt the xHCI host, and complete all URBs with an -ESHUTDOWN code.  Any code
+ * that sees this status (other than the timer that set it) should stop touching
+ * hardware immediately.  Interrupt handlers should return immediately when
+ * they see this status (any time they drop and re-acquire xhci->lock).
+ * xhci_urb_dequeue() should call usb_hcd_check_unlink_urb() and return without
+ * putting the TD on the canceled list, etc.
+ *
+ * There are no reports of xHCI host controllers that display this issue.
+ */
+#define XHCI_STATE_DYING        (1 << 0)
         /* Statistics */
         int                     noops_submitted;
         int                     noops_handled;
@@ -1188,6 +1214,8 @@ void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst);
 void xhci_dbg_cmd_ptrs(struct xhci_hcd *xhci);
 void xhci_dbg_ring_ptrs(struct xhci_hcd *xhci, struct xhci_ring *ring);
 void xhci_dbg_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx, unsigned int last_ep);
+char *xhci_get_slot_state(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *ctx);
 
 /* xHCI memory management */
 void xhci_mem_cleanup(struct xhci_hcd *xhci);
@@ -1211,8 +1239,12 @@ int xhci_endpoint_init(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev,
                 struct usb_device *udev, struct usb_host_endpoint *ep,
                 gfp_t mem_flags);
 void xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring);
+void xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci,
+                struct xhci_virt_device *virt_dev,
+                unsigned int ep_index);
 struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
-                bool allocate_completion, gfp_t mem_flags);
+                bool allocate_in_ctx, bool allocate_completion,
+                gfp_t mem_flags);
 void xhci_free_command(struct xhci_hcd *xhci,
                 struct xhci_command *command);
 
@@ -1223,6 +1255,7 @@ void xhci_unregister_pci(void);
 #endif
 
 /* xHCI host controller glue */
+void xhci_quiesce(struct xhci_hcd *xhci);
 int xhci_halt(struct xhci_hcd *xhci);
 int xhci_reset(struct xhci_hcd *xhci);
 int xhci_init(struct usb_hcd *hcd);
@@ -1241,11 +1274,16 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status);
 int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep);
 int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev, struct usb_host_endpoint *ep);
 void xhci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep);
+int xhci_reset_device(struct usb_hcd *hcd, struct usb_device *udev);
 int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev);
 void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev);
 
 /* xHCI ring, segment, TRB, and TD functions */
 dma_addr_t xhci_trb_virt_to_dma(struct xhci_segment *seg, union xhci_trb *trb);
+struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
+                union xhci_trb *start_trb, union xhci_trb *end_trb,
+                dma_addr_t suspect_dma);
+int xhci_is_vendor_info_code(struct xhci_hcd *xhci, unsigned int trb_comp_code);
 void xhci_ring_cmd_db(struct xhci_hcd *xhci);
 void *xhci_setup_one_noop(struct xhci_hcd *xhci);
 void xhci_handle_event(struct xhci_hcd *xhci);
@@ -1267,6 +1305,7 @@ int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
                 u32 slot_id);
 int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
                 unsigned int ep_index);
+int xhci_queue_reset_device(struct xhci_hcd *xhci, u32 slot_id);
 void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 struct xhci_td *cur_td, struct xhci_dequeue_state *state);
@@ -1278,6 +1317,7 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
 void xhci_queue_config_ep_quirk(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 struct xhci_dequeue_state *deq_state);
+void xhci_stop_endpoint_command_watchdog(unsigned long arg);
 
 /* xHCI roothub code */
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex,
diff --git a/drivers/usb/image/mdc800.c b/drivers/usb/image/mdc800.c
index eca355dccf65..e192e8f7c560 100644
--- a/drivers/usb/image/mdc800.c
+++ b/drivers/usb/image/mdc800.c
@@ -967,7 +967,7 @@ static const struct file_operations mdc800_device_ops =
 
 
 
-static struct usb_device_id mdc800_table [] = {
+static const struct usb_device_id mdc800_table[] = {
         { USB_DEVICE(MDC800_VENDOR_ID, MDC800_PRODUCT_ID) },
         { }                                             /* Terminating entry */
 };
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 459a7287fe01..3a6bcd5fee09 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -155,7 +155,7 @@ static int mts_usb_probe(struct usb_interface *intf,
                          const struct usb_device_id *id);
 static void mts_usb_disconnect(struct usb_interface *intf);
 
-static struct usb_device_id mts_usb_ids [];
+static const struct usb_device_id mts_usb_ids[];
 
 static struct usb_driver mts_usb_driver = {
         .name =         "microtekX6",
@@ -656,7 +656,7 @@ static struct scsi_host_template mts_scsi_host_template = {
 /* The entries of microtek_table must correspond, line-by-line to
    the entries of mts_supported_products[]. */
 
-static struct usb_device_id mts_usb_ids [] =
+static const struct usb_device_id mts_usb_ids[] =
 {
         { USB_DEVICE(0x4ce, 0x0300) },
         { USB_DEVICE(0x5da, 0x0094) },
diff --git a/drivers/usb/misc/Kconfig b/drivers/usb/misc/Kconfig
index abe3aa67ed00..55660eaf947c 100644
--- a/drivers/usb/misc/Kconfig
+++ b/drivers/usb/misc/Kconfig
@@ -87,17 +87,6 @@ config USB_LCD
           To compile this driver as a module, choose M here: the
           module will be called usblcd.
 
-config USB_BERRY_CHARGE
-        tristate "USB BlackBerry recharge support"
-        depends on USB
-        help
-          Say Y here if you want to connect a BlackBerry device to your
-          computer's USB port and have it automatically switch to "recharge"
-          mode.
-
-          To compile this driver as a module, choose M here: the
-          module will be called berry_charge.
-
 config USB_LED
         tristate "USB LED driver support"
         depends on USB
@@ -242,17 +231,3 @@ config USB_ISIGHTFW
           driver beforehand. Tools for doing so are available at
           http://bersace03.free.fr
 
-config USB_VST
-        tristate "USB VST driver"
-        depends on USB
-        help
-          This driver is intended for Vernier Software Technologies
-          bulk usb devices such as their Ocean-Optics spectrometers or
-          Labquest.
-          It is a bulk channel driver with configurable read and write
-          timeouts.
-
-          To compile this driver as a module, choose M here: the
-          module will be called vstusb.
-
-
diff --git a/drivers/usb/misc/Makefile b/drivers/usb/misc/Makefile
index 0826aab8303f..717703e81425 100644
--- a/drivers/usb/misc/Makefile
+++ b/drivers/usb/misc/Makefile
@@ -5,7 +5,6 @@
 
 obj-$(CONFIG_USB_ADUTUX)        += adutux.o
 obj-$(CONFIG_USB_APPLEDISPLAY)  += appledisplay.o
-obj-$(CONFIG_USB_BERRY_CHARGE)  += berry_charge.o
 obj-$(CONFIG_USB_CYPRESS_CY7C63)+= cypress_cy7c63.o
 obj-$(CONFIG_USB_CYTHERM)       += cytherm.o
 obj-$(CONFIG_USB_EMI26)         += emi26.o
@@ -23,7 +22,6 @@ obj-$(CONFIG_USB_TEST)		+= usbtest.o
 obj-$(CONFIG_USB_TRANCEVIBRATOR)        += trancevibrator.o
 obj-$(CONFIG_USB_USS720)        += uss720.o
 obj-$(CONFIG_USB_SEVSEG)        += usbsevseg.o
-obj-$(CONFIG_USB_VST)           += vstusb.o
 
 obj-$(CONFIG_USB_SISUSBVGA)     += sisusbvga/
 
diff --git a/drivers/usb/misc/adutux.c b/drivers/usb/misc/adutux.c
index 203526542013..d240de097c62 100644
--- a/drivers/usb/misc/adutux.c
+++ b/drivers/usb/misc/adutux.c
@@ -38,7 +38,7 @@ static int debug = 1;
 #define dbg(lvl, format, arg...)                                        \
 do {                                                                    \
         if (debug >= lvl)                                               \
-                printk(KERN_DEBUG __FILE__ " : " format " \n", ## arg); \
+                printk(KERN_DEBUG "%s: " format "\n", __FILE__, ##arg); \
 } while (0)
 
 
@@ -56,7 +56,7 @@ MODULE_PARM_DESC(debug, "Debug enabled or not");
 #define ADU_PRODUCT_ID 0x0064
 
 /* table of devices that work with this driver */
-static struct usb_device_id device_table [] = {
+static const struct usb_device_id device_table[] = {
         { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID) },          /* ADU100 */
         { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+20) },       /* ADU120 */
         { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+30) },       /* ADU130 */
@@ -132,8 +132,8 @@ static void adu_debug_data(int level, const char *function, int size,
         if (debug < level)
                 return;
 
-        printk(KERN_DEBUG __FILE__": %s - length = %d, data = ",
-               function, size);
+        printk(KERN_DEBUG "%s: %s - length = %d, data = ",
+               __FILE__, function, size);
         for (i = 0; i < size; ++i)
                 printk("%.2x ", data[i]);
         printk("\n");
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index 1d8e39a557d9..094f91cbc578 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -24,6 +24,7 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/backlight.h>
 #include <linux/timer.h>
@@ -57,9 +58,10 @@
         .bInterfaceProtocol = 0x00
 
 /* table of devices that work with this driver */
-static struct usb_device_id appledisplay_table [] = {
+static const struct usb_device_id appledisplay_table[] = {
         { APPLEDISPLAY_DEVICE(0x9218) },
         { APPLEDISPLAY_DEVICE(0x9219) },
+        { APPLEDISPLAY_DEVICE(0x921c) },
         { APPLEDISPLAY_DEVICE(0x921d) },
 
         /* Terminating entry */
@@ -72,8 +74,8 @@ struct appledisplay {
         struct usb_device *udev;        /* usb device */
         struct urb *urb;                /* usb request block */
         struct backlight_device *bd;    /* backlight device */
-        char *urbdata;                  /* interrupt URB data buffer */
-        char *msgdata;                  /* control message data buffer */
+        u8 *urbdata;                    /* interrupt URB data buffer */
+        u8 *msgdata;                    /* control message data buffer */
 
         struct delayed_work work;
         int button_pressed;
@@ -178,7 +180,7 @@ static int appledisplay_bl_get_brightness(struct backlight_device *bd)
                 return pdata->msgdata[1];
 }
 
-static struct backlight_ops appledisplay_bl_data = {
+static const struct backlight_ops appledisplay_bl_data = {
         .get_brightness = appledisplay_bl_get_brightness,
         .update_status  = appledisplay_bl_update_status,
 };
@@ -201,6 +203,7 @@ static void appledisplay_work(struct work_struct *work)
 static int appledisplay_probe(struct usb_interface *iface,
         const struct usb_device_id *id)
 {
+        struct backlight_properties props;
         struct appledisplay *pdata;
         struct usb_device *udev = interface_to_usbdev(iface);
         struct usb_host_interface *iface_desc;
@@ -278,15 +281,16 @@ static int appledisplay_probe(struct usb_interface *iface,
         /* Register backlight device */
         snprintf(bl_name, sizeof(bl_name), "appledisplay%d",
                 atomic_inc_return(&count_displays) - 1);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = 0xff;
         pdata->bd = backlight_device_register(bl_name, NULL, pdata,
-                                                &appledisplay_bl_data);
+                                              &appledisplay_bl_data, &props);
         if (IS_ERR(pdata->bd)) {
                 dev_err(&iface->dev, "Backlight registration failed\n");
+                retval = PTR_ERR(pdata->bd);
                 goto error;
         }
 
-        pdata->bd->props.max_brightness = 0xff;
-
         /* Try to get brightness */
         brightness = appledisplay_bl_get_brightness(pdata->bd);
 
diff --git a/drivers/usb/misc/berry_charge.c b/drivers/usb/misc/berry_charge.c
deleted file mode 100644
index c05a85bc5925..000000000000
--- a/drivers/usb/misc/berry_charge.c
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * USB BlackBerry charging module
- *
- * Copyright (C) 2007 Greg Kroah-Hartman <gregkh@suse.de>
- *
- *      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.
- *
- * Information on how to switch configs was taken by the bcharge.cc file
- * created by the barry.sf.net project.
- *
- * bcharge.cc has the following copyright:
- *      Copyright (C) 2006, Net Direct Inc. (http://www.netdirect.ca/)
- * and is released under the GPLv2.
- *
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/usb.h>
-
-#define RIM_VENDOR              0x0fca
-#define BLACKBERRY              0x0001
-#define BLACKBERRY_PEARL_DUAL   0x0004
-#define BLACKBERRY_PEARL        0x0006
-
-static int debug;
-static int pearl_dual_mode = 1;
-
-#ifdef dbg
-#undef dbg
-#endif
-#define dbg(dev, format, arg...)                                \
-        if (debug)                                              \
-                dev_printk(KERN_DEBUG , dev , format , ## arg)
-
-static struct usb_device_id id_table [] = {
-        { USB_DEVICE(RIM_VENDOR, BLACKBERRY) },
-        { USB_DEVICE(RIM_VENDOR, BLACKBERRY_PEARL) },
-        { USB_DEVICE(RIM_VENDOR, BLACKBERRY_PEARL_DUAL) },
-        { },                                    /* Terminating entry */
-};
-MODULE_DEVICE_TABLE(usb, id_table);
-
-static int magic_charge(struct usb_device *udev)
-{
-        char *dummy_buffer = kzalloc(2, GFP_KERNEL);
-        int retval;
-
-        if (!dummy_buffer)
-                return -ENOMEM;
-
-        /* send two magic commands and then set the configuration.  The device
-         * will then reset itself with the new power usage and should start
-         * charging. */
-
-        /* Note, with testing, it only seems that the first message is really
-         * needed (at least for the 8700c), but to be safe, we emulate what
-         * other operating systems seem to be sending to their device.  We
-         * really need to get some specs for this device to be sure about what
-         * is going on here.
-         */
-        dbg(&udev->dev, "Sending first magic command\n");
-        retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
-                                 0xa5, 0xc0, 0, 1, dummy_buffer, 2, 100);
-        if (retval != 2) {
-                dev_err(&udev->dev, "First magic command failed: %d.\n",
-                        retval);
-                goto exit;
-        }
-
-        dbg(&udev->dev, "Sending second magic command\n");
-        retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
-                                 0xa2, 0x40, 0, 1, dummy_buffer, 0, 100);
-        if (retval != 0) {
-                dev_err(&udev->dev, "Second magic command failed: %d.\n",
-                        retval);
-                goto exit;
-        }
-
-        dbg(&udev->dev, "Calling set_configuration\n");
-        retval = usb_driver_set_configuration(udev, 1);
-        if (retval)
-                dev_err(&udev->dev, "Set Configuration failed :%d.\n", retval);
-
-exit:
-        kfree(dummy_buffer);
-        return retval;
-}
-
-static int magic_dual_mode(struct usb_device *udev)
-{
-        char *dummy_buffer = kzalloc(2, GFP_KERNEL);
-        int retval;
-
-        if (!dummy_buffer)
-                return -ENOMEM;
-
-        /* send magic command so that the Blackberry Pearl device exposes
-         * two interfaces: both the USB mass-storage one and one which can
-         * be used for database access. */
-        dbg(&udev->dev, "Sending magic pearl command\n");
-        retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
-                                 0xa9, 0xc0, 1, 1, dummy_buffer, 2, 100);
-        dbg(&udev->dev, "Magic pearl command returned %d\n", retval);
-
-        dbg(&udev->dev, "Calling set_configuration\n");
-        retval = usb_driver_set_configuration(udev, 1);
-        if (retval)
-                dev_err(&udev->dev, "Set Configuration failed :%d.\n", retval);
-
-        kfree(dummy_buffer);
-        return retval;
-}
-
-static int berry_probe(struct usb_interface *intf,
-                       const struct usb_device_id *id)
-{
-        struct usb_device *udev = interface_to_usbdev(intf);
-
-        if (udev->bus_mA < 500) {
-                dbg(&udev->dev, "Not enough power to charge available\n");
-                return -ENODEV;
-        }
-
-        dbg(&udev->dev, "Power is set to %dmA\n",
-            udev->actconfig->desc.bMaxPower * 2);
-
-        /* check the power usage so we don't try to enable something that is
-         * already enabled */
-        if ((udev->actconfig->desc.bMaxPower * 2) == 500) {
-                dbg(&udev->dev, "device is already charging, power is "
-                    "set to %dmA\n", udev->actconfig->desc.bMaxPower * 2);
-                return -ENODEV;
-        }
-
-        /* turn the power on */
-        magic_charge(udev);
-
-        if ((le16_to_cpu(udev->descriptor.idProduct) == BLACKBERRY_PEARL) &&
-            (pearl_dual_mode))
-                magic_dual_mode(udev);
-
-        /* we don't really want to bind to the device, userspace programs can
-         * handle the syncing just fine, so get outta here. */
-        return -ENODEV;
-}
-
-static void berry_disconnect(struct usb_interface *intf)
-{
-}
-
-static struct usb_driver berry_driver = {
-        .name =         "berry_charge",
-        .probe =        berry_probe,
-        .disconnect =   berry_disconnect,
-        .id_table =     id_table,
-};
-
-static int __init berry_init(void)
-{
-        return usb_register(&berry_driver);
-}
-
-static void __exit berry_exit(void)
-{
-        usb_deregister(&berry_driver);
-}
-
-module_init(berry_init);
-module_exit(berry_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@suse.de>");
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
-module_param(pearl_dual_mode, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(pearl_dual_mode, "Change Blackberry Pearl to run in dual mode");
diff --git a/drivers/usb/misc/cypress_cy7c63.c b/drivers/usb/misc/cypress_cy7c63.c
index 5720bfef6a38..2f43c57743c9 100644
--- a/drivers/usb/misc/cypress_cy7c63.c
+++ b/drivers/usb/misc/cypress_cy7c63.c
@@ -32,6 +32,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 
 #define DRIVER_AUTHOR           "Oliver Bock (bock@tfh-berlin.de)"
@@ -56,7 +57,7 @@
 
 
 /* table of devices that work with this driver */
-static struct usb_device_id cypress_table [] = {
+static const struct usb_device_id cypress_table[] = {
         { USB_DEVICE(CYPRESS_VENDOR_ID, CYPRESS_PRODUCT_ID) },
         { }
 };
diff --git a/drivers/usb/misc/cytherm.c b/drivers/usb/misc/cytherm.c
index 4fb3c38b924b..1d7251bc1b5f 100644
--- a/drivers/usb/misc/cytherm.c
+++ b/drivers/usb/misc/cytherm.c
@@ -17,6 +17,7 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/usb.h>
 
@@ -27,7 +28,7 @@
 #define USB_SKEL_VENDOR_ID      0x04b4
 #define USB_SKEL_PRODUCT_ID     0x0002
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
         { }
 };
diff --git a/drivers/usb/misc/emi26.c b/drivers/usb/misc/emi26.c
index 879a980ca8c4..a6521c95f683 100644
--- a/drivers/usb/misc/emi26.c
+++ b/drivers/usb/misc/emi26.c
@@ -245,7 +245,7 @@ wraperr:
         return err;
 }
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(EMI26_VENDOR_ID, EMI26_PRODUCT_ID) },
         { USB_DEVICE(EMI26_VENDOR_ID, EMI26B_PRODUCT_ID) },
         { }                                             /* Terminating entry */
diff --git a/drivers/usb/misc/emi62.c b/drivers/usb/misc/emi62.c
index 602ee05ba9ff..fc15ad4c3139 100644
--- a/drivers/usb/misc/emi62.c
+++ b/drivers/usb/misc/emi62.c
@@ -167,7 +167,7 @@ static int emi62_load_firmware (struct usb_device *dev)
                         err("%s - error loading firmware: error = %d", __func__, err);
                         goto wraperr;
                 }
-        } while (i > 0);
+        } while (rec);
 
         /* Assert reset (stop the CPU in the EMI) */
         err = emi62_set_reset(dev,1);
@@ -259,7 +259,7 @@ wraperr:
         return err;
 }
 
-static __devinitdata struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] __devinitconst = {
         { USB_DEVICE(EMI62_VENDOR_ID, EMI62_PRODUCT_ID) },
         { }                                             /* Terminating entry */
 };
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index 9d0675ed0d4c..1edb6d361896 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -86,7 +86,7 @@ static struct list_head ftdi_static_list;
 #define USB_FTDI_ELAN_VENDOR_ID 0x0403
 #define USB_FTDI_ELAN_PRODUCT_ID 0xd6ea
 /* table of devices that work with this driver*/
-static struct usb_device_id ftdi_elan_table[] = {
+static const struct usb_device_id ftdi_elan_table[] = {
         {USB_DEVICE(USB_FTDI_ELAN_VENDOR_ID, USB_FTDI_ELAN_PRODUCT_ID)},
         { /* Terminating entry */ }
 };
@@ -623,9 +623,12 @@ static void ftdi_elan_status_work(struct work_struct *work)
 */
 static int ftdi_elan_open(struct inode *inode, struct file *file)
 {
-        int subminor = iminor(inode);
-        struct usb_interface *interface = usb_find_interface(&ftdi_elan_driver,
-                subminor);
+        int subminor;
+        struct usb_interface *interface;
+
+        subminor = iminor(inode);
+        interface = usb_find_interface(&ftdi_elan_driver, subminor);
+
         if (!interface) {
                 printk(KERN_ERR "can't find device for minor %d\n", subminor);
                 return -ENODEV;
diff --git a/drivers/usb/misc/idmouse.c b/drivers/usb/misc/idmouse.c
index 1337a9ce80b9..a54c3cb804ce 100644
--- a/drivers/usb/misc/idmouse.c
+++ b/drivers/usb/misc/idmouse.c
@@ -48,7 +48,7 @@
 #define ID_CHERRY  0x0010
 
 /* device ID table */
-static struct usb_device_id idmouse_table[] = {
+static const struct usb_device_id idmouse_table[] = {
         {USB_DEVICE(ID_SIEMENS, ID_IDMOUSE)}, /* Siemens ID Mouse (Professional) */
         {USB_DEVICE(ID_SIEMENS, ID_CHERRY )}, /* Cherry FingerTIP ID Board       */
         {}                                    /* terminating null entry          */
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index e75bb87ee92b..d3c852363883 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -139,7 +139,7 @@ static int usb_set_report(struct usb_interface *intf, unsigned char type,
 /* driver registration */
 /*---------------------*/
 /* table of devices that work with this driver */
-static struct usb_device_id iowarrior_ids[] = {
+static const struct usb_device_id iowarrior_ids[] = {
         {USB_DEVICE(USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOW40)},
         {USB_DEVICE(USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOW24)},
         {USB_DEVICE(USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOWPV1)},
@@ -602,10 +602,12 @@ static int iowarrior_open(struct inode *inode, struct file *file)
 
         dbg("%s", __func__);
 
+        lock_kernel();
         subminor = iminor(inode);
 
         interface = usb_find_interface(&iowarrior_driver, subminor);
         if (!interface) {
+                unlock_kernel();
                 err("%s - error, can't find device for minor %d", __func__,
                     subminor);
                 return -ENODEV;
@@ -615,6 +617,7 @@ static int iowarrior_open(struct inode *inode, struct file *file)
         dev = usb_get_intfdata(interface);
         if (!dev) {
                 mutex_unlock(&iowarrior_open_disc_lock);
+                unlock_kernel();
                 return -ENODEV;
         }
 
@@ -641,6 +644,7 @@ static int iowarrior_open(struct inode *inode, struct file *file)
 
 out:
         mutex_unlock(&dev->mutex);
+        unlock_kernel();
         return retval;
 }
 
diff --git a/drivers/usb/misc/isight_firmware.c b/drivers/usb/misc/isight_firmware.c
index b897f6554ecd..fe1d44319d0a 100644
--- a/drivers/usb/misc/isight_firmware.c
+++ b/drivers/usb/misc/isight_firmware.c
@@ -25,8 +25,9 @@
 #include <linux/firmware.h>
 #include <linux/errno.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 
-static struct usb_device_id id_table[] = {
+static const struct usb_device_id id_table[] = {
         {USB_DEVICE(0x05ac, 0x8300)},
         {},
 };
@@ -112,6 +113,8 @@ out:
         return ret;
 }
 
+MODULE_FIRMWARE("isight.fw");
+
 static void isight_firmware_disconnect(struct usb_interface *intf)
 {
 }
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index 90f130126c10..dd41d8710043 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -69,7 +69,7 @@
 #endif
 
 /* table of devices that work with this driver */
-static struct usb_device_id ld_usb_table [] = {
+static const struct usb_device_id ld_usb_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
         { USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
@@ -798,7 +798,7 @@ static int __init ld_usb_init(void)
         /* register this driver with the USB subsystem */
         retval = usb_register(&ld_usb_driver);
         if (retval)
-                err("usb_register failed for the "__FILE__" driver. Error number %d\n", retval);
+                err("usb_register failed for the %s driver. Error number %d\n", __FILE__, retval);
 
         return retval;
 }
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index faa6d623de78..8547bf9e3175 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -95,8 +95,11 @@
 
 /* Use our own dbg macro */
 #undef dbg
-#define dbg(lvl, format, arg...) do { if (debug >= lvl) printk(KERN_DEBUG  __FILE__ ": " format "\n", ## arg); } while (0)
-
+#define dbg(lvl, format, arg...)                                        \
+do {                                                                    \
+        if (debug >= lvl)                                               \
+                printk(KERN_DEBUG "%s: " format "\n", __FILE__, ##arg); \
+} while (0)
 
 /* Version Information */
 #define DRIVER_VERSION "v0.96"
@@ -192,7 +195,7 @@ struct tower_get_version_reply {
 
 
 /* table of devices that work with this driver */
-static struct usb_device_id tower_table [] = {
+static const struct usb_device_id tower_table[] = {
         { USB_DEVICE(LEGO_USB_TOWER_VENDOR_ID, LEGO_USB_TOWER_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
@@ -302,7 +305,7 @@ static inline void lego_usb_tower_debug_data (int level, const char *function, i
         if (debug < level)
                 return;
 
-        printk (KERN_DEBUG __FILE__": %s - length = %d, data = ", function, size);
+        printk (KERN_DEBUG "%s: %s - length = %d, data = ", __FILE__, function, size);
         for (i = 0; i < size; ++i) {
                 printk ("%.2x ", data[i]);
         }
@@ -1055,7 +1058,7 @@ static int __init lego_usb_tower_init(void)
         /* register this driver with the USB subsystem */
         result = usb_register(&tower_driver);
         if (result < 0) {
-                err("usb_register failed for the "__FILE__" driver. Error number %d", result);
+                err("usb_register failed for the %s driver. Error number %d", __FILE__, result);
                 retval = -1;
                 goto exit;
         }
diff --git a/drivers/usb/misc/rio500.c b/drivers/usb/misc/rio500.c
index 32d0199d0c32..a85771b1563d 100644
--- a/drivers/usb/misc/rio500.c
+++ b/drivers/usb/misc/rio500.c
@@ -78,10 +78,13 @@ static int open_rio(struct inode *inode, struct file *file)
 {
         struct rio_usb_data *rio = &rio_instance;
 
+        /* against disconnect() */
+        lock_kernel();
         mutex_lock(&(rio->lock));
 
         if (rio->isopen || !rio->present) {
                 mutex_unlock(&(rio->lock));
+                unlock_kernel();
                 return -EBUSY;
         }
         rio->isopen = 1;
@@ -91,6 +94,7 @@ static int open_rio(struct inode *inode, struct file *file)
         mutex_unlock(&(rio->lock));
 
         dev_info(&rio->rio_dev->dev, "Rio opened.\n");
+        unlock_kernel();
 
         return 0;
 }
@@ -115,7 +119,6 @@ static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
         int retries;
         int retval=0;
 
-        lock_kernel();
         mutex_lock(&(rio->lock));
         /* Sanity check to make sure rio is connected, powered, etc */
         if (rio->present == 0 || rio->rio_dev == NULL) {
@@ -254,7 +257,6 @@ static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
 
 err_out:
         mutex_unlock(&(rio->lock));
-        unlock_kernel();
         return retval;
 }
 
@@ -489,6 +491,7 @@ static void disconnect_rio(struct usb_interface *intf)
         struct rio_usb_data *rio = usb_get_intfdata (intf);
 
         usb_set_intfdata (intf, NULL);
+        lock_kernel();
         if (rio) {
                 usb_deregister_dev(intf, &usb_rio_class);
 
@@ -498,6 +501,7 @@ static void disconnect_rio(struct usb_interface *intf)
                         /* better let it finish - the release will do whats needed */
                         rio->rio_dev = NULL;
                         mutex_unlock(&(rio->lock));
+                        unlock_kernel();
                         return;
                 }
                 kfree(rio->ibuf);
@@ -508,9 +512,10 @@ static void disconnect_rio(struct usb_interface *intf)
                 rio->present = 0;
                 mutex_unlock(&(rio->lock));
         }
+        unlock_kernel();
 }
 
-static struct usb_device_id rio_table [] = {
+static const struct usb_device_id rio_table[] = {
         { USB_DEVICE(0x0841, 1) },              /* Rio 500 */
         { }                                     /* Terminating entry */
 };
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index 0025847743f3..aae95a009bd5 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -250,7 +250,7 @@ sisusb_bulkout_msg(struct sisusb_usb_data *sisusb, int index, unsigned int pipe,
         sisusb->urbstatus[index] |= SU_URB_BUSY;
 
         /* Submit URB */
-        retval = usb_submit_urb(urb, GFP_ATOMIC);
+        retval = usb_submit_urb(urb, GFP_KERNEL);
 
         /* If OK, and if timeout > 0, wait for completion */
         if ((retval == 0) && timeout) {
@@ -306,7 +306,7 @@ sisusb_bulkin_msg(struct sisusb_usb_data *sisusb, unsigned int pipe, void *data,
         urb->actual_length = 0;
 
         sisusb->completein = 0;
-        retval = usb_submit_urb(urb, GFP_ATOMIC);
+        retval = usb_submit_urb(urb, GFP_KERNEL);
         if (retval == 0) {
                 wait_event_timeout(sisusb->wait_q, sisusb->completein, timeout);
                 if (!sisusb->completein) {
@@ -2416,21 +2416,28 @@ sisusb_open(struct inode *inode, struct file *file)
         struct usb_interface *interface;
         int subminor = iminor(inode);
 
-        if (!(interface = usb_find_interface(&sisusb_driver, subminor)))
+        lock_kernel();
+        if (!(interface = usb_find_interface(&sisusb_driver, subminor))) {
+                unlock_kernel();
                 return -ENODEV;
+        }
 
-        if (!(sisusb = usb_get_intfdata(interface)))
+        if (!(sisusb = usb_get_intfdata(interface))) {
+                unlock_kernel();
                 return -ENODEV;
+        }
 
         mutex_lock(&sisusb->lock);
 
         if (!sisusb->present || !sisusb->ready) {
                 mutex_unlock(&sisusb->lock);
+                unlock_kernel();
                 return -ENODEV;
         }
 
         if (sisusb->isopen) {
                 mutex_unlock(&sisusb->lock);
+                unlock_kernel();
                 return -EBUSY;
         }
 
@@ -2439,11 +2446,13 @@ sisusb_open(struct inode *inode, struct file *file)
                         if (sisusb_init_gfxdevice(sisusb, 0)) {
                                 mutex_unlock(&sisusb->lock);
                                 dev_err(&sisusb->sisusb_dev->dev, "Failed to initialize device\n");
+                                unlock_kernel();
                                 return -EIO;
                         }
                 } else {
                         mutex_unlock(&sisusb->lock);
                         dev_err(&sisusb->sisusb_dev->dev, "Device not attached to USB 2.0 hub\n");
+                        unlock_kernel();
                         return -EIO;
                 }
         }
@@ -2456,6 +2465,7 @@ sisusb_open(struct inode *inode, struct file *file)
         file->private_data = sisusb;
 
         mutex_unlock(&sisusb->lock);
+        unlock_kernel();
 
         return 0;
 }
@@ -3238,13 +3248,14 @@ static void sisusb_disconnect(struct usb_interface *intf)
         kref_put(&sisusb->kref, sisusb_delete);
 }
 
-static struct usb_device_id sisusb_table [] = {
+static const struct usb_device_id sisusb_table[] = {
         { USB_DEVICE(0x0711, 0x0550) },
         { USB_DEVICE(0x0711, 0x0900) },
         { USB_DEVICE(0x0711, 0x0901) },
         { USB_DEVICE(0x0711, 0x0902) },
         { USB_DEVICE(0x0711, 0x0903) },
         { USB_DEVICE(0x0711, 0x0918) },
+        { USB_DEVICE(0x0711, 0x0920) },
         { USB_DEVICE(0x182d, 0x021c) },
         { USB_DEVICE(0x182d, 0x0269) },
         { }
diff --git a/drivers/usb/misc/sisusbvga/sisusb_con.c b/drivers/usb/misc/sisusbvga/sisusb_con.c
index b624320df903..b271b0557a1f 100644
--- a/drivers/usb/misc/sisusbvga/sisusb_con.c
+++ b/drivers/usb/misc/sisusbvga/sisusb_con.c
@@ -58,7 +58,6 @@
 #include <linux/string.h>
 #include <linux/kd.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/vt_kern.h>
 #include <linux/selection.h>
 #include <linux/spinlock.h>
diff --git a/drivers/usb/misc/sisusbvga/sisusb_init.c b/drivers/usb/misc/sisusbvga/sisusb_init.c
index 0ab990744830..cb8a3d91f970 100644
--- a/drivers/usb/misc/sisusbvga/sisusb_init.c
+++ b/drivers/usb/misc/sisusbvga/sisusb_init.c
@@ -41,7 +41,6 @@
 #include <linux/errno.h>
 #include <linux/poll.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/spinlock.h>
 
 #include "sisusb.h"
diff --git a/drivers/usb/misc/trancevibrator.c b/drivers/usb/misc/trancevibrator.c
index 2e14102955c5..d77aba46ae85 100644
--- a/drivers/usb/misc/trancevibrator.c
+++ b/drivers/usb/misc/trancevibrator.c
@@ -22,6 +22,7 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/usb.h>
 
@@ -33,7 +34,7 @@
 #define TRANCEVIBRATOR_VENDOR_ID        0x0b49  /* ASCII Corporation */
 #define TRANCEVIBRATOR_PRODUCT_ID       0x064f  /* Trance Vibrator */
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(TRANCEVIBRATOR_VENDOR_ID, TRANCEVIBRATOR_PRODUCT_ID) },
         { },
 };
diff --git a/drivers/usb/misc/usblcd.c b/drivers/usb/misc/usblcd.c
index 4fb120357c55..90aede90553e 100644
--- a/drivers/usb/misc/usblcd.c
+++ b/drivers/usb/misc/usblcd.c
@@ -30,7 +30,7 @@
 #define IOCTL_GET_DRV_VERSION   2
 
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { .idVendor = 0x10D2, .match_flags = USB_DEVICE_ID_MATCH_VENDOR, },
         { },
 };
@@ -74,10 +74,12 @@ static int lcd_open(struct inode *inode, struct file *file)
         struct usb_interface *interface;
         int subminor, r;
 
+        lock_kernel();
         subminor = iminor(inode);
 
         interface = usb_find_interface(&lcd_driver, subminor);
         if (!interface) {
+                unlock_kernel();
                 err ("USBLCD: %s - error, can't find device for minor %d",
                      __func__, subminor);
                 return -ENODEV;
@@ -87,6 +89,7 @@ static int lcd_open(struct inode *inode, struct file *file)
         dev = usb_get_intfdata(interface);
         if (!dev) {
                 mutex_unlock(&open_disc_mutex);
+                unlock_kernel();
                 return -ENODEV;
         }
 
@@ -98,11 +101,13 @@ static int lcd_open(struct inode *inode, struct file *file)
         r = usb_autopm_get_interface(interface);
         if (r < 0) {
                 kref_put(&dev->kref, lcd_delete);
+                unlock_kernel();
                 return r;
         }
 
         /* save our object in the file's private structure */
         file->private_data = dev;
+        unlock_kernel();
 
         return 0;
 }
diff --git a/drivers/usb/misc/usbled.c b/drivers/usb/misc/usbled.c
index 06cb71942dc7..63da2c3c838f 100644
--- a/drivers/usb/misc/usbled.c
+++ b/drivers/usb/misc/usbled.c
@@ -24,7 +24,7 @@
 #define PRODUCT_ID      0x1223
 
 /* table of devices that work with this driver */
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(VENDOR_ID, PRODUCT_ID) },
         { },
 };
diff --git a/drivers/usb/misc/usbsevseg.c b/drivers/usb/misc/usbsevseg.c
index 3db255537e79..de8ef945b536 100644
--- a/drivers/usb/misc/usbsevseg.c
+++ b/drivers/usb/misc/usbsevseg.c
@@ -27,7 +27,7 @@
 #define MAXLEN          6
 
 /* table of devices that work with this driver */
-static struct usb_device_id id_table[] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(VENDOR_ID, PRODUCT_ID) },
         { },
 };
@@ -49,6 +49,7 @@ struct usb_sevsegdev {
         u16 textlength;
 
         u8 shadow_power; /* for PM */
+        u8 has_interface_pm;
 };
 
 /* sysfs_streq can't replace this completely
@@ -68,12 +69,16 @@ static void update_display_powered(struct usb_sevsegdev *mydev)
 {
         int rc;
 
-        if (!mydev->shadow_power && mydev->powered) {
+        if (mydev->powered && !mydev->has_interface_pm) {
                 rc = usb_autopm_get_interface(mydev->intf);
                 if (rc < 0)
                         return;
+                mydev->has_interface_pm = 1;
         }
 
+        if (mydev->shadow_power != 1)
+                return;
+
         rc = usb_control_msg(mydev->udev,
                         usb_sndctrlpipe(mydev->udev, 0),
                         0x12,
@@ -86,8 +91,10 @@ static void update_display_powered(struct usb_sevsegdev *mydev)
         if (rc < 0)
                 dev_dbg(&mydev->udev->dev, "power retval = %d\n", rc);
 
-        if (mydev->shadow_power && !mydev->powered)
+        if (!mydev->powered && mydev->has_interface_pm) {
                 usb_autopm_put_interface(mydev->intf);
+                mydev->has_interface_pm = 0;
+        }
 }
 
 static void update_display_mode(struct usb_sevsegdev *mydev)
@@ -351,6 +358,10 @@ static int sevseg_probe(struct usb_interface *interface,
         mydev->intf = interface;
         usb_set_intfdata(interface, mydev);
 
+        /* PM */
+        mydev->shadow_power = 1; /* currently active */
+        mydev->has_interface_pm = 0; /* have not issued autopm_get */
+
         /*set defaults */
         mydev->textmode = 0x02; /* ascii mode */
         mydev->mode_msb = 0x06; /* 6 characters */
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index a9f06d76960f..a21cce6f7403 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -213,8 +213,9 @@ 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)");
+static unsigned mod_pattern;
+module_param_named(pattern, mod_pattern, uint, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(mod_pattern, "i/o pattern (0 == zeroes)");
 
 static inline void simple_fill_buf (struct urb *urb)
 {
@@ -1567,6 +1568,8 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
 
         // FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is.
 
+        pattern = mod_pattern;
+
         if (code != USBTEST_REQUEST)
                 return -EOPNOTSUPP;
 
@@ -1577,10 +1580,6 @@ usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
                 return -ERESTARTSYS;
 
         /* FIXME: What if a system sleep starts while a test is running? */
-        if (!intf->is_active) {
-                mutex_unlock(&dev->lock);
-                return -EHOSTUNREACH;
-        }
 
         /* some devices, like ez-usb default devices, need a non-default
          * altsetting to have any active endpoints.  some tests change
@@ -2098,7 +2097,7 @@ static struct usbtest_info generic_info = {
 #endif
 
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
 
         /*-------------------------------------------------------------*/
 
diff --git a/drivers/usb/misc/uss720.c b/drivers/usb/misc/uss720.c
index 9a6c27a01793..796e2f68f749 100644
--- a/drivers/usb/misc/uss720.c
+++ b/drivers/usb/misc/uss720.c
@@ -49,6 +49,7 @@
 #include <linux/delay.h>
 #include <linux/completion.h>
 #include <linux/kref.h>
+#include <linux/slab.h>
 
 /*
  * Version Information
@@ -770,7 +771,7 @@ static void uss720_disconnect(struct usb_interface *intf)
 }
 
 /* table of cables that work through this driver */
-static struct usb_device_id uss720_table [] = {
+static const struct usb_device_id uss720_table[] = {
         { USB_DEVICE(0x047e, 0x1001) },
         { USB_DEVICE(0x0557, 0x2001) },
         { USB_DEVICE(0x0729, 0x1284) },
diff --git a/drivers/usb/misc/vstusb.c b/drivers/usb/misc/vstusb.c
deleted file mode 100644
index f26ea8dc1577..000000000000
--- a/drivers/usb/misc/vstusb.c
+++ /dev/null
@@ -1,783 +0,0 @@
-/*****************************************************************************
- *  File: drivers/usb/misc/vstusb.c
- *
- *  Purpose: Support for the bulk USB Vernier Spectrophotometers
- *
- *  Author:     Johnnie Peters
- *              Axian Consulting
- *              Beaverton, OR, USA 97005
- *
- *  Modified by:     EQware Engineering, Inc.
- *                   Oregon City, OR, USA 97045
- *
- *  Copyright:  2007, 2008
- *              Vernier Software & Technology
- *              Beaverton, OR, USA 97005
- *
- *  Web:        www.vernier.com
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- *
- *****************************************************************************/
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/mutex.h>
-#include <linux/uaccess.h>
-#include <linux/usb.h>
-
-#include <linux/usb/vstusb.h>
-
-#define DRIVER_VERSION "VST USB Driver Version 1.5"
-#define DRIVER_DESC "Vernier Software Technology Bulk USB Driver"
-
-#ifdef CONFIG_USB_DYNAMIC_MINORS
-        #define VSTUSB_MINOR_BASE       0
-#else
-        #define VSTUSB_MINOR_BASE       199
-#endif
-
-#define USB_VENDOR_OCEANOPTICS  0x2457
-#define USB_VENDOR_VERNIER      0x08F7  /* Vernier Software & Technology */
-
-#define USB_PRODUCT_USB2000     0x1002
-#define USB_PRODUCT_ADC1000_FW  0x1003  /* firmware download (renumerates) */
-#define USB_PRODUCT_ADC1000     0x1004
-#define USB_PRODUCT_HR2000_FW   0x1009  /* firmware download (renumerates) */
-#define USB_PRODUCT_HR2000      0x100A
-#define USB_PRODUCT_HR4000_FW   0x1011  /* firmware download (renumerates) */
-#define USB_PRODUCT_HR4000      0x1012
-#define USB_PRODUCT_USB650      0x1014  /* "Red Tide" */
-#define USB_PRODUCT_QE65000     0x1018
-#define USB_PRODUCT_USB4000     0x1022
-#define USB_PRODUCT_USB325      0x1024  /* "Vernier Spectrometer" */
-
-#define USB_PRODUCT_LABPRO      0x0001
-#define USB_PRODUCT_LABQUEST    0x0005
-
-#define VST_MAXBUFFER           (64*1024)
-
-static struct usb_device_id id_table[] = {
-        { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_USB2000)},
-        { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_HR4000)},
-        { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_USB650)},
-        { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_USB4000)},
-        { USB_DEVICE(USB_VENDOR_OCEANOPTICS, USB_PRODUCT_USB325)},
-        { USB_DEVICE(USB_VENDOR_VERNIER, USB_PRODUCT_LABQUEST)},
-        { USB_DEVICE(USB_VENDOR_VERNIER, USB_PRODUCT_LABPRO)},
-        {},
-};
-
-MODULE_DEVICE_TABLE(usb, id_table);
-
-struct vstusb_device {
-        struct kref                             kref;
-        struct mutex            lock;
-        struct usb_device       *usb_dev;
-        char                    present;
-        char                    isopen;
-        struct usb_anchor       submitted;
-        int                     rd_pipe;
-        int                     rd_timeout_ms;
-        int                     wr_pipe;
-        int                     wr_timeout_ms;
-};
-#define to_vst_dev(d) container_of(d, struct vstusb_device, kref)
-
-static struct usb_driver vstusb_driver;
-
-static void vstusb_delete(struct kref *kref)
-{
-        struct vstusb_device *vstdev = to_vst_dev(kref);
-
-        usb_put_dev(vstdev->usb_dev);
-        kfree(vstdev);
-}
-
-static int vstusb_open(struct inode *inode, struct file *file)
-{
-        struct vstusb_device *vstdev;
-        struct usb_interface *interface;
-
-        interface = usb_find_interface(&vstusb_driver, iminor(inode));
-
-        if (!interface) {
-                printk(KERN_ERR KBUILD_MODNAME
-                       ": %s - error, can't find device for minor %d\n",
-                       __func__, iminor(inode));
-                return -ENODEV;
-        }
-
-        vstdev = usb_get_intfdata(interface);
-
-        if (!vstdev)
-                return -ENODEV;
-
-        /* lock this device */
-        mutex_lock(&vstdev->lock);
-
-        /* can only open one time */
-        if ((!vstdev->present) || (vstdev->isopen)) {
-                mutex_unlock(&vstdev->lock);
-                return -EBUSY;
-        }
-
-        /* increment our usage count */
-        kref_get(&vstdev->kref);
-
-        vstdev->isopen = 1;
-
-        /* save device in the file's private structure */
-        file->private_data = vstdev;
-
-        dev_dbg(&vstdev->usb_dev->dev, "%s: opened\n", __func__);
-
-        mutex_unlock(&vstdev->lock);
-
-        return 0;
-}
-
-static int vstusb_release(struct inode *inode, struct file *file)
-{
-        struct vstusb_device *vstdev;
-
-        vstdev = file->private_data;
-
-        if (vstdev == NULL)
-                return -ENODEV;
-
-        mutex_lock(&vstdev->lock);
-
-        vstdev->isopen = 0;
-
-        dev_dbg(&vstdev->usb_dev->dev, "%s: released\n", __func__);
-
-        mutex_unlock(&vstdev->lock);
-
-        kref_put(&vstdev->kref, vstusb_delete);
-
-        return 0;
-}
-
-static void usb_api_blocking_completion(struct urb *urb)
-{
-        struct completion *completeit = urb->context;
-
-        complete(completeit);
-}
-
-static int vstusb_fill_and_send_urb(struct urb *urb,
-                                    struct usb_device *usb_dev,
-                                    unsigned int pipe, void *data,
-                                    unsigned int len, struct completion *done)
-{
-        struct usb_host_endpoint *ep;
-        struct usb_host_endpoint **hostep;
-        unsigned int pipend;
-
-        int status;
-
-        hostep = usb_pipein(pipe) ? usb_dev->ep_in : usb_dev->ep_out;
-        pipend = usb_pipeendpoint(pipe);
-        ep = hostep[pipend];
-
-        if (!ep || (len == 0))
-                return -EINVAL;
-
-        if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
-            == USB_ENDPOINT_XFER_INT) {
-                pipe = (pipe & ~(3 << 30)) | (PIPE_INTERRUPT << 30);
-                usb_fill_int_urb(urb, usb_dev, pipe, data, len,
-                                 (usb_complete_t)usb_api_blocking_completion,
-                                 NULL, ep->desc.bInterval);
-        } else
-                usb_fill_bulk_urb(urb, usb_dev, pipe, data, len,
-                                  (usb_complete_t)usb_api_blocking_completion,
-                                  NULL);
-
-        init_completion(done);
-        urb->context = done;
-        urb->actual_length = 0;
-        status = usb_submit_urb(urb, GFP_KERNEL);
-
-        return status;
-}
-
-static int vstusb_complete_urb(struct urb *urb, struct completion *done,
-                               int timeout, int *actual_length)
-{
-        unsigned long expire;
-        int status;
-
-        expire = timeout ? msecs_to_jiffies(timeout) : MAX_SCHEDULE_TIMEOUT;
-        if (!wait_for_completion_interruptible_timeout(done, expire)) {
-                usb_kill_urb(urb);
-                status = urb->status == -ENOENT ? -ETIMEDOUT : urb->status;
-
-                dev_dbg(&urb->dev->dev,
-                        "%s timed out on ep%d%s len=%d/%d, urb status = %d\n",
-                        current->comm,
-                        usb_pipeendpoint(urb->pipe),
-                        usb_pipein(urb->pipe) ? "in" : "out",
-                        urb->actual_length,
-                        urb->transfer_buffer_length,
-                        urb->status);
-
-        } else {
-                if (signal_pending(current)) {
-                        /* if really an error */
-                        if (urb->status && !((urb->status == -ENOENT)     ||
-                                             (urb->status == -ECONNRESET) ||
-                                             (urb->status == -ESHUTDOWN))) {
-                                status = -EINTR;
-                                usb_kill_urb(urb);
-                        } else {
-                                status = 0;
-                        }
-
-                        dev_dbg(&urb->dev->dev,
-                                "%s: signal pending on ep%d%s len=%d/%d,"
-                                "urb status = %d\n",
-                                current->comm,
-                                usb_pipeendpoint(urb->pipe),
-                                usb_pipein(urb->pipe) ? "in" : "out",
-                                urb->actual_length,
-                                urb->transfer_buffer_length,
-                                urb->status);
-
-                } else {
-                        status = urb->status;
-                }
-        }
-
-        if (actual_length)
-                *actual_length = urb->actual_length;
-
-        return status;
-}
-
-static ssize_t vstusb_read(struct file *file, char __user *buffer,
-                           size_t count, loff_t *ppos)
-{
-        struct vstusb_device *vstdev;
-        int cnt = -1;
-        void *buf;
-        int retval = 0;
-
-        struct urb              *urb;
-        struct usb_device       *dev;
-        unsigned int            pipe;
-        int                     timeout;
-
-        DECLARE_COMPLETION_ONSTACK(done);
-
-        vstdev = file->private_data;
-
-        if (vstdev == NULL)
-                return -ENODEV;
-
-        /* verify that we actually want to read some data */
-        if ((count == 0) || (count > VST_MAXBUFFER))
-                return -EINVAL;
-
-        /* lock this object */
-        if (mutex_lock_interruptible(&vstdev->lock))
-                return -ERESTARTSYS;
-
-        /* anyone home */
-        if (!vstdev->present) {
-                mutex_unlock(&vstdev->lock);
-                printk(KERN_ERR KBUILD_MODNAME
-                       ": %s: device not present\n", __func__);
-                return -ENODEV;
-        }
-
-        /* pull out the necessary data */
-        dev =     vstdev->usb_dev;
-        pipe =    usb_rcvbulkpipe(dev, vstdev->rd_pipe);
-        timeout = vstdev->rd_timeout_ms;
-
-        buf = kmalloc(count, GFP_KERNEL);
-        if (buf == NULL) {
-                mutex_unlock(&vstdev->lock);
-                return -ENOMEM;
-        }
-
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                kfree(buf);
-                mutex_unlock(&vstdev->lock);
-                return -ENOMEM;
-        }
-
-        usb_anchor_urb(urb, &vstdev->submitted);
-        retval = vstusb_fill_and_send_urb(urb, dev, pipe, buf, count, &done);
-        mutex_unlock(&vstdev->lock);
-        if (retval) {
-                usb_unanchor_urb(urb);
-                dev_err(&dev->dev, "%s: error %d filling and sending urb %d\n",
-                        __func__, retval, pipe);
-                goto exit;
-        }
-
-        retval = vstusb_complete_urb(urb, &done, timeout, &cnt);
-        if (retval) {
-                dev_err(&dev->dev, "%s: error %d completing urb %d\n",
-                        __func__, retval, pipe);
-                goto exit;
-        }
-
-        if (copy_to_user(buffer, buf, cnt)) {
-                dev_err(&dev->dev, "%s: can't copy_to_user\n", __func__);
-                retval = -EFAULT;
-        } else {
-                retval = cnt;
-                dev_dbg(&dev->dev, "%s: read %d bytes from pipe %d\n",
-                        __func__, cnt, pipe);
-        }
-
-exit:
-        usb_free_urb(urb);
-        kfree(buf);
-        return retval;
-}
-
-static ssize_t vstusb_write(struct file *file, const char __user *buffer,
-                            size_t count, loff_t *ppos)
-{
-        struct vstusb_device *vstdev;
-        int cnt = -1;
-        void *buf;
-        int retval = 0;
-
-        struct urb              *urb;
-        struct usb_device       *dev;
-        unsigned int            pipe;
-        int                     timeout;
-
-        DECLARE_COMPLETION_ONSTACK(done);
-
-        vstdev = file->private_data;
-
-        if (vstdev == NULL)
-                return -ENODEV;
-
-        /* verify that we actually have some data to write */
-        if ((count == 0) || (count > VST_MAXBUFFER))
-                return retval;
-
-        /* lock this object */
-        if (mutex_lock_interruptible(&vstdev->lock))
-                return -ERESTARTSYS;
-
-        /* anyone home */
-        if (!vstdev->present) {
-                mutex_unlock(&vstdev->lock);
-                printk(KERN_ERR KBUILD_MODNAME
-                       ": %s: device not present\n", __func__);
-                return -ENODEV;
-        }
-
-        /* pull out the necessary data */
-        dev =     vstdev->usb_dev;
-        pipe =    usb_sndbulkpipe(dev, vstdev->wr_pipe);
-        timeout = vstdev->wr_timeout_ms;
-
-        buf = kmalloc(count, GFP_KERNEL);
-        if (buf == NULL) {
-                mutex_unlock(&vstdev->lock);
-                return -ENOMEM;
-        }
-
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                kfree(buf);
-                mutex_unlock(&vstdev->lock);
-                return -ENOMEM;
-        }
-
-        if (copy_from_user(buf, buffer, count)) {
-                mutex_unlock(&vstdev->lock);
-                dev_err(&dev->dev, "%s: can't copy_from_user\n", __func__);
-                retval = -EFAULT;
-                goto exit;
-        }
-
-        usb_anchor_urb(urb, &vstdev->submitted);
-        retval = vstusb_fill_and_send_urb(urb, dev, pipe, buf, count, &done);
-        mutex_unlock(&vstdev->lock);
-        if (retval) {
-                usb_unanchor_urb(urb);
-                dev_err(&dev->dev, "%s: error %d filling and sending urb %d\n",
-                        __func__, retval, pipe);
-                goto exit;
-        }
-
-        retval = vstusb_complete_urb(urb, &done, timeout, &cnt);
-        if (retval) {
-                dev_err(&dev->dev, "%s: error %d completing urb %d\n",
-                        __func__, retval, pipe);
-                goto exit;
-        } else {
-                retval = cnt;
-                dev_dbg(&dev->dev, "%s: sent %d bytes to pipe %d\n",
-                        __func__, cnt, pipe);
-        }
-
-exit:
-        usb_free_urb(urb);
-        kfree(buf);
-        return retval;
-}
-
-static long vstusb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
-{
-        int retval = 0;
-        int cnt = -1;
-        void __user *data = (void __user *)arg;
-        struct vstusb_args usb_data;
-
-        struct vstusb_device *vstdev;
-        void *buffer = NULL; /* must be initialized. buffer is
-                              * referenced on exit but not all
-                              * ioctls allocate it */
-
-        struct urb              *urb = NULL; /* must be initialized. urb is
-                                              * referenced on exit but not all
-                                              * ioctls allocate it */
-        struct usb_device       *dev;
-        unsigned int            pipe;
-        int                     timeout;
-
-        DECLARE_COMPLETION_ONSTACK(done);
-
-        vstdev = file->private_data;
-
-        if (_IOC_TYPE(cmd) != VST_IOC_MAGIC) {
-                dev_warn(&vstdev->usb_dev->dev,
-                         "%s: ioctl command %x, bad ioctl magic %x, "
-                         "expected %x\n", __func__, cmd,
-                         _IOC_TYPE(cmd), VST_IOC_MAGIC);
-                return -EINVAL;
-        }
-
-        if (vstdev == NULL)
-                return -ENODEV;
-
-        if (copy_from_user(&usb_data, data, sizeof(struct vstusb_args))) {
-                dev_err(&vstdev->usb_dev->dev, "%s: can't copy_from_user\n",
-                        __func__);
-                return -EFAULT;
-        }
-
-        /* lock this object */
-        if (mutex_lock_interruptible(&vstdev->lock)) {
-                retval = -ERESTARTSYS;
-                goto exit;
-        }
-
-        /* anyone home */
-        if (!vstdev->present) {
-                mutex_unlock(&vstdev->lock);
-                dev_err(&vstdev->usb_dev->dev, "%s: device not present\n",
-                        __func__);
-                retval = -ENODEV;
-                goto exit;
-        }
-
-        /* pull out the necessary data */
-        dev = vstdev->usb_dev;
-
-        switch (cmd) {
-
-        case IOCTL_VSTUSB_CONFIG_RW:
-
-                vstdev->rd_pipe = usb_data.rd_pipe;
-                vstdev->rd_timeout_ms = usb_data.rd_timeout_ms;
-                vstdev->wr_pipe = usb_data.wr_pipe;
-                vstdev->wr_timeout_ms = usb_data.wr_timeout_ms;
-
-                mutex_unlock(&vstdev->lock);
-
-                dev_dbg(&dev->dev, "%s: setting pipes/timeouts, "
-                        "rdpipe = %d, rdtimeout = %d, "
-                        "wrpipe = %d, wrtimeout = %d\n", __func__,
-                        vstdev->rd_pipe, vstdev->rd_timeout_ms,
-                        vstdev->wr_pipe, vstdev->wr_timeout_ms);
-                break;
-
-        case IOCTL_VSTUSB_SEND_PIPE:
-
-                if ((usb_data.count == 0) || (usb_data.count > VST_MAXBUFFER)) {
-                        mutex_unlock(&vstdev->lock);
-                        retval = -EINVAL;
-                        goto exit;
-                }
-
-                buffer = kmalloc(usb_data.count, GFP_KERNEL);
-                if (buffer == NULL) {
-                        mutex_unlock(&vstdev->lock);
-                        retval = -ENOMEM;
-                        goto exit;
-                }
-
-                urb = usb_alloc_urb(0, GFP_KERNEL);
-                if (!urb) {
-                        mutex_unlock(&vstdev->lock);
-                        retval = -ENOMEM;
-                        goto exit;
-                }
-
-                timeout = usb_data.timeout_ms;
-
-                pipe = usb_sndbulkpipe(dev, usb_data.pipe);
-
-                if (copy_from_user(buffer, usb_data.buffer, usb_data.count)) {
-                        dev_err(&dev->dev, "%s: can't copy_from_user\n",
-                                __func__);
-                        mutex_unlock(&vstdev->lock);
-                        retval = -EFAULT;
-                        goto exit;
-                }
-
-                usb_anchor_urb(urb, &vstdev->submitted);
-                retval = vstusb_fill_and_send_urb(urb, dev, pipe, buffer,
-                                                  usb_data.count, &done);
-                mutex_unlock(&vstdev->lock);
-                if (retval) {
-                        usb_unanchor_urb(urb);
-                        dev_err(&dev->dev,
-                                "%s: error %d filling and sending urb %d\n",
-                                __func__, retval, pipe);
-                        goto exit;
-                }
-
-                retval = vstusb_complete_urb(urb, &done, timeout, &cnt);
-                if (retval) {
-                        dev_err(&dev->dev, "%s: error %d completing urb %d\n",
-                                __func__, retval, pipe);
-                }
-
-                break;
-        case IOCTL_VSTUSB_RECV_PIPE:
-
-                if ((usb_data.count == 0) || (usb_data.count > VST_MAXBUFFER)) {
-                        mutex_unlock(&vstdev->lock);
-                        retval = -EINVAL;
-                        goto exit;
-                }
-
-                buffer = kmalloc(usb_data.count, GFP_KERNEL);
-                if (buffer == NULL) {
-                        mutex_unlock(&vstdev->lock);
-                        retval = -ENOMEM;
-                        goto exit;
-                }
-
-                urb = usb_alloc_urb(0, GFP_KERNEL);
-                if (!urb) {
-                        mutex_unlock(&vstdev->lock);
-                        retval = -ENOMEM;
-                        goto exit;
-                }
-
-                timeout = usb_data.timeout_ms;
-
-                pipe = usb_rcvbulkpipe(dev, usb_data.pipe);
-
-                usb_anchor_urb(urb, &vstdev->submitted);
-                retval = vstusb_fill_and_send_urb(urb, dev, pipe, buffer,
-                                                  usb_data.count, &done);
-                mutex_unlock(&vstdev->lock);
-                if (retval) {
-                        usb_unanchor_urb(urb);
-                        dev_err(&dev->dev,
-                                "%s: error %d filling and sending urb %d\n",
-                                __func__, retval, pipe);
-                        goto exit;
-                }
-
-                retval = vstusb_complete_urb(urb, &done, timeout, &cnt);
-                if (retval) {
-                        dev_err(&dev->dev, "%s: error %d completing urb %d\n",
-                                __func__, retval, pipe);
-                        goto exit;
-                }
-
-                if (copy_to_user(usb_data.buffer, buffer, cnt)) {
-                        dev_err(&dev->dev, "%s: can't copy_to_user\n",
-                                __func__);
-                        retval = -EFAULT;
-                        goto exit;
-                }
-
-                usb_data.count = cnt;
-                if (copy_to_user(data, &usb_data, sizeof(struct vstusb_args))) {
-                        dev_err(&dev->dev, "%s: can't copy_to_user\n",
-                                __func__);
-                        retval = -EFAULT;
-                } else {
-                        dev_dbg(&dev->dev, "%s: recv %zd bytes from pipe %d\n",
-                                __func__, usb_data.count, usb_data.pipe);
-                }
-
-                break;
-
-        default:
-                mutex_unlock(&vstdev->lock);
-                dev_warn(&dev->dev, "ioctl_vstusb: invalid ioctl cmd %x\n",
-                         cmd);
-                return -EINVAL;
-                break;
-        }
-exit:
-        usb_free_urb(urb);
-        kfree(buffer);
-        return retval;
-}
-
-static const struct file_operations vstusb_fops = {
-        .owner =                THIS_MODULE,
-        .read =                 vstusb_read,
-        .write =                vstusb_write,
-        .unlocked_ioctl =       vstusb_ioctl,
-        .compat_ioctl =         vstusb_ioctl,
-        .open =                 vstusb_open,
-        .release =              vstusb_release,
-};
-
-static struct usb_class_driver usb_vstusb_class = {
-        .name =         "usb/vstusb%d",
-        .fops =         &vstusb_fops,
-        .minor_base =   VSTUSB_MINOR_BASE,
-};
-
-static int vstusb_probe(struct usb_interface *intf,
-                        const struct usb_device_id *id)
-{
-        struct usb_device *dev = interface_to_usbdev(intf);
-        struct vstusb_device *vstdev;
-        int i;
-        int retval = 0;
-
-        /* allocate memory for our device state and intialize it */
-
-        vstdev = kzalloc(sizeof(*vstdev), GFP_KERNEL);
-        if (vstdev == NULL)
-                return -ENOMEM;
-
-        /* must do usb_get_dev() prior to kref_init() since the kref_put()
-         * release function will do a usb_put_dev() */
-        usb_get_dev(dev);
-        kref_init(&vstdev->kref);
-        mutex_init(&vstdev->lock);
-
-        i = dev->descriptor.bcdDevice;
-
-        dev_dbg(&intf->dev, "Version %1d%1d.%1d%1d found at address %d\n",
-                (i & 0xF000) >> 12, (i & 0xF00) >> 8,
-                (i & 0xF0) >> 4, (i & 0xF), dev->devnum);
-
-        vstdev->present = 1;
-        vstdev->isopen = 0;
-        vstdev->usb_dev = dev;
-        init_usb_anchor(&vstdev->submitted);
-
-        usb_set_intfdata(intf, vstdev);
-        retval = usb_register_dev(intf, &usb_vstusb_class);
-        if (retval) {
-                dev_err(&intf->dev,
-                        "%s: Not able to get a minor for this device.\n",
-                        __func__);
-                usb_set_intfdata(intf, NULL);
-                kref_put(&vstdev->kref, vstusb_delete);
-                return retval;
-        }
-
-        /* let the user know what node this device is now attached to */
-        dev_info(&intf->dev,
-                 "VST USB Device #%d now attached to major %d minor %d\n",
-                 (intf->minor - VSTUSB_MINOR_BASE), USB_MAJOR, intf->minor);
-
-        dev_info(&intf->dev, "%s, %s\n", DRIVER_DESC, DRIVER_VERSION);
-
-        return retval;
-}
-
-static void vstusb_disconnect(struct usb_interface *intf)
-{
-        struct vstusb_device *vstdev = usb_get_intfdata(intf);
-
-        usb_deregister_dev(intf, &usb_vstusb_class);
-        usb_set_intfdata(intf, NULL);
-
-        if (vstdev) {
-
-                mutex_lock(&vstdev->lock);
-                vstdev->present = 0;
-
-                usb_kill_anchored_urbs(&vstdev->submitted);
-
-                mutex_unlock(&vstdev->lock);
-
-                kref_put(&vstdev->kref, vstusb_delete);
-        }
-
-}
-
-static int vstusb_suspend(struct usb_interface *intf, pm_message_t message)
-{
-        struct vstusb_device *vstdev = usb_get_intfdata(intf);
-        int time;
-        if (!vstdev)
-                return 0;
-
-        mutex_lock(&vstdev->lock);
-        time = usb_wait_anchor_empty_timeout(&vstdev->submitted, 1000);
-        if (!time)
-                usb_kill_anchored_urbs(&vstdev->submitted);
-        mutex_unlock(&vstdev->lock);
-
-        return 0;
-}
-
-static int vstusb_resume(struct usb_interface *intf)
-{
-        return 0;
-}
-
-static struct usb_driver vstusb_driver = {
-        .name =         "vstusb",
-        .probe =        vstusb_probe,
-        .disconnect =   vstusb_disconnect,
-        .suspend =      vstusb_suspend,
-        .resume =       vstusb_resume,
-        .id_table = id_table,
-};
-
-static int __init vstusb_init(void)
-{
-        int rc;
-
-        rc = usb_register(&vstusb_driver);
-        if (rc)
-                printk(KERN_ERR "%s: failed to register (%d)", __func__, rc);
-
-        return rc;
-}
-
-static void __exit vstusb_exit(void)
-{
-        usb_deregister(&vstusb_driver);
-}
-
-module_init(vstusb_init);
-module_exit(vstusb_exit);
-
-MODULE_AUTHOR("Dennis O'Brien/Stephen Ware");
-MODULE_DESCRIPTION(DRIVER_VERSION);
-MODULE_LICENSE("GPL");
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index 10f3205798e8..ddf7f9a1b336 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -16,6 +16,8 @@
 #include <linux/compat.h>
 #include <linux/mm.h>
 #include <linux/smp_lock.h>
+#include <linux/scatterlist.h>
+#include <linux/slab.h>
 
 #include <asm/uaccess.h>
 
@@ -221,7 +223,7 @@ static void mon_free_buff(struct mon_pgmap *map, int npages);
 /*
  * This is a "chunked memcpy". It does not manipulate any counters.
  */
-static void mon_copy_to_buff(const struct mon_reader_bin *this,
+static unsigned int mon_copy_to_buff(const struct mon_reader_bin *this,
     unsigned int off, const unsigned char *from, unsigned int length)
 {
         unsigned int step_len;
@@ -246,6 +248,7 @@ static void mon_copy_to_buff(const struct mon_reader_bin *this,
                 from += step_len;
                 length -= step_len;
         }
+        return off;
 }
 
 /*
@@ -394,14 +397,44 @@ static inline char mon_bin_get_setup(unsigned char *setupb,
         return 0;
 }
 
-static char mon_bin_get_data(const struct mon_reader_bin *rp,
-    unsigned int offset, struct urb *urb, unsigned int length)
+static unsigned int mon_bin_get_data(const struct mon_reader_bin *rp,
+    unsigned int offset, struct urb *urb, unsigned int length,
+    char *flag)
 {
+        int i;
+        struct scatterlist *sg;
+        unsigned int this_len;
+
+        *flag = 0;
+        if (urb->num_sgs == 0) {
+                if (urb->transfer_buffer == NULL) {
+                        *flag = 'Z';
+                        return length;
+                }
+                mon_copy_to_buff(rp, offset, urb->transfer_buffer, length);
+                length = 0;
 
-        if (urb->transfer_buffer == NULL)
-                return 'Z';
-        mon_copy_to_buff(rp, offset, urb->transfer_buffer, length);
-        return 0;
+        } else {
+                /* If IOMMU coalescing occurred, we cannot trust sg_page */
+                if (urb->sg->nents != urb->num_sgs) {
+                        *flag = 'D';
+                        return length;
+                }
+
+                /* Copy up to the first non-addressable segment */
+                for_each_sg(urb->sg->sg, sg, urb->num_sgs, i) {
+                        if (length == 0 || PageHighMem(sg_page(sg)))
+                                break;
+                        this_len = min_t(unsigned int, sg->length, length);
+                        offset = mon_copy_to_buff(rp, offset, sg_virt(sg),
+                                        this_len);
+                        length -= this_len;
+                }
+                if (i == 0)
+                        *flag = 'D';
+        }
+
+        return length;
 }
 
 static void mon_bin_get_isodesc(const struct mon_reader_bin *rp,
@@ -428,8 +461,8 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
     char ev_type, int status)
 {
         const struct usb_endpoint_descriptor *epd = &urb->ep->desc;
-        unsigned long flags;
         struct timeval ts;
+        unsigned long flags;
         unsigned int urb_length;
         unsigned int offset;
         unsigned int length;
@@ -536,8 +569,9 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
         }
 
         if (length != 0) {
-                ep->flag_data = mon_bin_get_data(rp, offset, urb, length);
-                if (ep->flag_data != 0) {       /* Yes, it's 0x00, not '0' */
+                length = mon_bin_get_data(rp, offset, urb, length,
+                                &ep->flag_data);
+                if (length > 0) {
                         delta = (ep->len_cap + PKT_ALIGN-1) & ~(PKT_ALIGN-1);
                         ep->len_cap -= length;
                         delta -= (ep->len_cap + PKT_ALIGN-1) & ~(PKT_ALIGN-1);
@@ -567,10 +601,13 @@ static void mon_bin_complete(void *data, struct urb *urb, int status)
 static void mon_bin_error(void *data, struct urb *urb, int error)
 {
         struct mon_reader_bin *rp = data;
+        struct timeval ts;
         unsigned long flags;
         unsigned int offset;
         struct mon_bin_hdr *ep;
 
+        do_gettimeofday(&ts);
+
         spin_lock_irqsave(&rp->b_lock, flags);
 
         offset = mon_buff_area_alloc(rp, PKT_SIZE);
@@ -590,6 +627,8 @@ static void mon_bin_error(void *data, struct urb *urb, int error)
         ep->devnum = urb->dev->devnum;
         ep->busnum = urb->dev->bus->busnum;
         ep->id = (unsigned long) urb;
+        ep->ts_sec = ts.tv_sec;
+        ep->ts_usec = ts.tv_usec;
         ep->status = error;
 
         ep->flag_setup = '-';
diff --git a/drivers/usb/mon/mon_main.c b/drivers/usb/mon/mon_main.c
index e0c2db3b767b..e4af18b93c7d 100644
--- a/drivers/usb/mon/mon_main.c
+++ b/drivers/usb/mon/mon_main.c
@@ -9,6 +9,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/usb.h>
+#include <linux/slab.h>
 #include <linux/notifier.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/usb/mon/mon_stat.c b/drivers/usb/mon/mon_stat.c
index ac8b0d5ce7f8..1becdc3837e6 100644
--- a/drivers/usb/mon/mon_stat.c
+++ b/drivers/usb/mon/mon_stat.c
@@ -8,6 +8,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/fs.h>
 #include <asm/uaccess.h>
diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c
index 9f1a9227ebe6..4d0be130f49b 100644
--- a/drivers/usb/mon/mon_text.c
+++ b/drivers/usb/mon/mon_text.c
@@ -7,9 +7,11 @@
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/usb.h>
+#include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/mutex.h>
 #include <linux/debugfs.h>
+#include <linux/scatterlist.h>
 #include <asm/uaccess.h>
 
 #include "usb_mon.h"
@@ -137,6 +139,8 @@ static inline char mon_text_get_setup(struct mon_event_text *ep,
 static inline char mon_text_get_data(struct mon_event_text *ep, struct urb *urb,
     int len, char ev_type, struct mon_bus *mbus)
 {
+        void *src;
+
         if (len <= 0)
                 return 'L';
         if (len >= DATA_MAX)
@@ -150,10 +154,24 @@ static inline char mon_text_get_data(struct mon_event_text *ep, struct urb *urb,
                         return '>';
         }
 
-        if (urb->transfer_buffer == NULL)
-                return 'Z';     /* '0' would be not as pretty. */
+        if (urb->num_sgs == 0) {
+                src = urb->transfer_buffer;
+                if (src == NULL)
+                        return 'Z';     /* '0' would be not as pretty. */
+        } else {
+                struct scatterlist *sg = urb->sg->sg;
+
+                /* If IOMMU coalescing occurred, we cannot trust sg_page */
+                if (urb->sg->nents != urb->num_sgs ||
+                                PageHighMem(sg_page(sg)))
+                        return 'D';
 
-        memcpy(ep->data, urb->transfer_buffer, len);
+                /* For the text interface we copy only the first sg buffer */
+                len = min_t(int, sg->length, len);
+                src = sg_virt(sg);
+        }
+
+        memcpy(ep->data, src, len);
         return 0;
 }
 
@@ -163,7 +181,7 @@ static inline unsigned int mon_get_timestamp(void)
         unsigned int stamp;
 
         do_gettimeofday(&tval);
-        stamp = tval.tv_sec & 0xFFFF;   /* 2^32 = 4294967296. Limit to 4096s. */
+        stamp = tval.tv_sec & 0xFFF;    /* 2^32 = 4294967296. Limit to 4096s. */
         stamp = stamp * 1000000 + tval.tv_usec;
         return stamp;
 }
@@ -256,12 +274,12 @@ static void mon_text_error(void *data, struct urb *urb, int error)
 
         ep->type = 'E';
         ep->id = (unsigned long) urb;
-        ep->busnum = 0;
+        ep->busnum = urb->dev->bus->busnum;
         ep->devnum = urb->dev->devnum;
         ep->epnum = usb_endpoint_num(&urb->ep->desc);
         ep->xfertype = usb_endpoint_type(&urb->ep->desc);
         ep->is_in = usb_urb_dir_in(urb);
-        ep->tstamp = 0;
+        ep->tstamp = mon_get_timestamp();
         ep->length = 0;
         ep->status = error;
 
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index b84abd8ee8a5..07fe490b44d8 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -9,10 +9,9 @@ comment "Enable Host or Gadget support to see Inventra options"
 # (M)HDRC = (Multipoint) Highspeed Dual-Role Controller
 config USB_MUSB_HDRC
         depends on (USB || USB_GADGET)
-        depends on (ARM || BLACKFIN)
-        select NOP_USB_XCEIV if ARCH_DAVINCI
+        depends on (ARM || (BF54x && !BF544) || (BF52x && !BF522 && !BF523))
+        select NOP_USB_XCEIV if (ARCH_DAVINCI || MACH_OMAP3EVM || BLACKFIN)
         select TWL4030_USB if MACH_OMAP_3430SDP
-        select NOP_USB_XCEIV if MACH_OMAP3EVM
         select USB_OTG_UTILS
         tristate 'Inventra Highspeed Dual Role Controller (TI, ADI, ...)'
         help
@@ -38,18 +37,18 @@ config USB_MUSB_SOC
         depends on USB_MUSB_HDRC
         default y if ARCH_DAVINCI
         default y if ARCH_OMAP2430
-        default y if ARCH_OMAP34XX
+        default y if ARCH_OMAP3
         default y if (BF54x && !BF544)
         default y if (BF52x && !BF522 && !BF523)
 
 comment "DaVinci 35x and 644x USB support"
-        depends on USB_MUSB_HDRC && ARCH_DAVINCI
+        depends on USB_MUSB_HDRC && ARCH_DAVINCI_DMx
 
 comment "OMAP 243x high speed USB support"
         depends on USB_MUSB_HDRC && ARCH_OMAP2430
 
 comment "OMAP 343x high speed USB support"
-        depends on USB_MUSB_HDRC && ARCH_OMAP34XX
+        depends on USB_MUSB_HDRC && ARCH_OMAP3
 
 comment "Blackfin high speed USB Support"
         depends on USB_MUSB_HDRC && ((BF54x && !BF544) || (BF52x && !BF522 && !BF523))
@@ -154,7 +153,7 @@ config MUSB_PIO_ONLY
 config USB_INVENTRA_DMA
         bool
         depends on USB_MUSB_HDRC && !MUSB_PIO_ONLY
-        default ARCH_OMAP2430 || ARCH_OMAP34XX || BLACKFIN
+        default ARCH_OMAP2430 || ARCH_OMAP3 || BLACKFIN
         help
           Enable DMA transfers using Mentor's engine.
 
diff --git a/drivers/usb/musb/Makefile b/drivers/usb/musb/Makefile
index 85710ccc1887..3a485dabebbb 100644
--- a/drivers/usb/musb/Makefile
+++ b/drivers/usb/musb/Makefile
@@ -6,7 +6,7 @@ musb_hdrc-objs := musb_core.o
 
 obj-$(CONFIG_USB_MUSB_HDRC)     += musb_hdrc.o
 
-ifeq ($(CONFIG_ARCH_DAVINCI),y)
+ifeq ($(CONFIG_ARCH_DAVINCI_DMx),y)
         musb_hdrc-objs  += davinci.o
 endif
 
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index fcec87ea709e..ec8d324237f6 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -11,7 +11,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/gpio.h>
@@ -29,6 +28,7 @@ void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
 {
         void __iomem *fifo = hw_ep->fifo;
         void __iomem *epio = hw_ep->regs;
+        u8 epnum = hw_ep->epnum;
 
         prefetch((u8 *)src);
 
@@ -39,14 +39,51 @@ void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
 
         dump_fifo_data(src, len);
 
-        if (unlikely((unsigned long)src & 0x01))
-                outsw_8((unsigned long)fifo, src,
-                        len & 0x01 ? (len >> 1) + 1 : len >> 1);
-        else
-                outsw((unsigned long)fifo, src,
-                        len & 0x01 ? (len >> 1) + 1 : len >> 1);
-}
+        if (!ANOMALY_05000380 && epnum != 0) {
+                u16 dma_reg;
+
+                flush_dcache_range((unsigned long)src,
+                        (unsigned long)(src + len));
+
+                /* Setup DMA address register */
+                dma_reg = (u32)src;
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_ADDR_LOW), dma_reg);
+                SSYNC();
+
+                dma_reg = (u32)src >> 16;
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_ADDR_HIGH), dma_reg);
+                SSYNC();
+
+                /* Setup DMA count register */
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_COUNT_LOW), len);
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_COUNT_HIGH), 0);
+                SSYNC();
+
+                /* Enable the DMA */
+                dma_reg = (epnum << 4) | DMA_ENA | INT_ENA | DIRECTION;
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_CTRL), dma_reg);
+                SSYNC();
+
+                /* Wait for compelete */
+                while (!(bfin_read_USB_DMA_INTERRUPT() & (1 << epnum)))
+                        cpu_relax();
+
+                /* acknowledge dma interrupt */
+                bfin_write_USB_DMA_INTERRUPT(1 << epnum);
+                SSYNC();
 
+                /* Reset DMA */
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_CTRL), 0);
+                SSYNC();
+        } else {
+                SSYNC();
+
+                if (unlikely((unsigned long)src & 0x01))
+                        outsw_8((unsigned long)fifo, src, (len + 1) >> 1);
+                else
+                        outsw((unsigned long)fifo, src, (len + 1) >> 1);
+        }
+}
 /*
  * Unload an endpoint's FIFO
  */
@@ -54,53 +91,62 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
 {
         void __iomem *fifo = hw_ep->fifo;
         u8 epnum = hw_ep->epnum;
-        u16 dma_reg = 0;
 
-        DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
-                        'R', hw_ep->epnum, fifo, len, dst);
+        if (ANOMALY_05000467 && epnum != 0) {
+                u16 dma_reg;
 
-#ifdef CONFIG_BF52x
-        invalidate_dcache_range((unsigned int)dst,
-                (unsigned int)(dst + len));
+                invalidate_dcache_range((unsigned long)dst,
+                        (unsigned long)(dst + len));
 
-        /* Setup DMA address register */
-        dma_reg = (u16) ((u32) dst & 0xFFFF);
-        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_ADDR_LOW), dma_reg);
-        SSYNC();
+                /* Setup DMA address register */
+                dma_reg = (u32)dst;
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_ADDR_LOW), dma_reg);
+                SSYNC();
 
-        dma_reg = (u16) (((u32) dst >> 16) & 0xFFFF);
-        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_ADDR_HIGH), dma_reg);
-        SSYNC();
+                dma_reg = (u32)dst >> 16;
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_ADDR_HIGH), dma_reg);
+                SSYNC();
 
-        /* Setup DMA count register */
-        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_COUNT_LOW), len);
-        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_COUNT_HIGH), 0);
-        SSYNC();
+                /* Setup DMA count register */
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_COUNT_LOW), len);
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_COUNT_HIGH), 0);
+                SSYNC();
 
-        /* Enable the DMA */
-        dma_reg = (epnum << 4) | DMA_ENA | INT_ENA;
-        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_CTRL), dma_reg);
-        SSYNC();
+                /* Enable the DMA */
+                dma_reg = (epnum << 4) | DMA_ENA | INT_ENA;
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_CTRL), dma_reg);
+                SSYNC();
 
-        /* Wait for compelete */
-        while (!(bfin_read_USB_DMA_INTERRUPT() & (1 << epnum)))
-                cpu_relax();
+                /* Wait for compelete */
+                while (!(bfin_read_USB_DMA_INTERRUPT() & (1 << epnum)))
+                        cpu_relax();
 
-        /* acknowledge dma interrupt */
-        bfin_write_USB_DMA_INTERRUPT(1 << epnum);
-        SSYNC();
+                /* acknowledge dma interrupt */
+                bfin_write_USB_DMA_INTERRUPT(1 << epnum);
+                SSYNC();
 
-        /* Reset DMA */
-        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_CTRL), 0);
-        SSYNC();
-#else
-        if (unlikely((unsigned long)dst & 0x01))
-                insw_8((unsigned long)fifo, dst,
-                        len & 0x01 ? (len >> 1) + 1 : len >> 1);
-        else
-                insw((unsigned long)fifo, dst,
-                        len & 0x01 ? (len >> 1) + 1 : len >> 1);
-#endif
+                /* Reset DMA */
+                bfin_write16(USB_DMA_REG(epnum, USB_DMAx_CTRL), 0);
+                SSYNC();
+        } else {
+                SSYNC();
+                /* Read the last byte of packet with odd size from address fifo + 4
+                 * to trigger 1 byte access to EP0 FIFO.
+                 */
+                if (len == 1)
+                        *dst = (u8)inw((unsigned long)fifo + 4);
+                else {
+                        if (unlikely((unsigned long)dst & 0x01))
+                                insw_8((unsigned long)fifo, dst, len >> 1);
+                        else
+                                insw((unsigned long)fifo, dst, len >> 1);
+
+                        if (len & 0x01)
+                                *(dst + len - 1) = (u8)inw((unsigned long)fifo + 4);
+                }
+        }
+        DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
+                        'R', hw_ep->epnum, fifo, len, dst);
 
         dump_fifo_data(dst, len);
 }
@@ -126,13 +172,7 @@ static irqreturn_t blackfin_interrupt(int irq, void *__hci)
 
         spin_unlock_irqrestore(&musb->lock, flags);
 
-        /* REVISIT we sometimes get spurious IRQs on g_ep0
-         * not clear why... fall in BF54x too.
-         */
-        if (retval != IRQ_HANDLED)
-                DBG(5, "spurious?\n");
-
-        return IRQ_HANDLED;
+        return retval;
 }
 
 static void musb_conn_timer_handler(unsigned long _musb)
@@ -225,8 +265,9 @@ int musb_platform_get_vbus_status(struct musb *musb)
         return 0;
 }
 
-void musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
 {
+        return -EIO;
 }
 
 int __init musb_platform_init(struct musb *musb)
@@ -261,10 +302,6 @@ int __init musb_platform_init(struct musb *musb)
                 SSYNC();
         }
 
-        /* TODO
-         * Set SIC-IVG register
-         */
-
         /* Configure PLL oscillator register */
         bfin_write_USB_PLLOSC_CTRL(0x30a8);
         SSYNC();
diff --git a/drivers/usb/musb/blackfin.h b/drivers/usb/musb/blackfin.h
index a240c1e53d16..bd9352a2ef2a 100644
--- a/drivers/usb/musb/blackfin.h
+++ b/drivers/usb/musb/blackfin.h
@@ -14,6 +14,43 @@
  * Blackfin specific definitions
  */
 
+/* Anomalies notes:
+ *
+ *  05000450 - USB DMA Mode 1 Short Packet Data Corruption:
+ *             MUSB driver is designed to transfer buffer of N * maxpacket size
+ *             in DMA mode 1 and leave the rest of the data to the next
+ *             transfer in DMA mode 0, so we never transmit a short packet in
+ *             DMA mode 1.
+ *
+ *  05000463 - This anomaly doesn't affect this driver since it
+ *             never uses L1 or L2 memory as data destination.
+ *
+ *  05000464 - This anomaly doesn't affect this driver since it
+ *             never uses L1 or L2 memory as data source.
+ *
+ *  05000465 - The anomaly can be seen when SCLK is over 100 MHz, and there is
+ *             no way to workaround for bulk endpoints.  Since the wMaxPackSize
+ *             of bulk is less than or equal to 512, while the fifo size of
+ *             endpoint 5, 6, 7 is 1024, the double buffer mode is enabled
+ *             automatically when these endpoints are used for bulk OUT.
+ *
+ *  05000466 - This anomaly doesn't affect this driver since it never mixes
+ *             concurrent DMA and core accesses to the TX endpoint FIFOs.
+ *
+ *  05000467 - The workaround for this anomaly will introduce another
+ *             anomaly - 05000465.
+ */
+
+/* The Mentor USB DMA engine on BF52x (silicon v0.0 and v0.1) seems to be
+ * unstable in host mode.  This may be caused by Anomaly 05000380.  After
+ * digging out the root cause, we will change this number accordingly.
+ * So, need to either use silicon v0.2+ or disable DMA mode in MUSB.
+ */
+#if ANOMALY_05000380 && defined(CONFIG_BF52x) && \
+    defined(CONFIG_USB_MUSB_HDRC) && !defined(CONFIG_MUSB_PIO_ONLY)
+# error "Please use PIO mode in MUSB driver on bf52x chip v0.0 and v0.1"
+#endif
+
 #undef DUMP_FIFO_DATA
 #ifdef DUMP_FIFO_DATA
 static void dump_fifo_data(u8 *buf, u16 len)
@@ -32,7 +69,6 @@ static void dump_fifo_data(u8 *buf, u16 len)
 #define dump_fifo_data(buf, len)        do {} while (0)
 #endif
 
-#ifdef CONFIG_BF52x
 
 #define USB_DMA_BASE            USB_DMA_INTERRUPT
 #define USB_DMAx_CTRL           0x04
@@ -42,7 +78,6 @@ static void dump_fifo_data(u8 *buf, u16 len)
 #define USB_DMAx_COUNT_HIGH     0x14
 
 #define USB_DMA_REG(ep, reg)    (USB_DMA_BASE + 0x20 * ep + reg)
-#endif
 
 /* Almost 1 second */
 #define TIMER_DELAY     (1 * HZ)
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c
index ef2332a9941d..59dc3d351b60 100644
--- a/drivers/usb/musb/cppi_dma.c
+++ b/drivers/usb/musb/cppi_dma.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 
 #include "musb_core.h"
@@ -1154,8 +1155,11 @@ irqreturn_t cppi_interrupt(int irq, void *dev_id)
         struct musb_hw_ep       *hw_ep = NULL;
         u32                     rx, tx;
         int                     i, index;
+        unsigned long           flags;
 
         cppi = container_of(musb->dma_controller, struct cppi, controller);
+        if (cppi->irq)
+                spin_lock_irqsave(&musb->lock, flags);
 
         tibase = musb->ctrl_base;
 
@@ -1188,8 +1192,13 @@ irqreturn_t cppi_interrupt(int irq, void *dev_id)
 
                 bd = tx_ch->head;
 
+                /*
+                 * If Head is null then this could mean that a abort interrupt
+                 * that needs to be acknowledged.
+                 */
                 if (NULL == bd) {
                         DBG(1, "null BD\n");
+                        tx_ram->tx_complete = 0;
                         continue;
                 }
 
@@ -1285,6 +1294,9 @@ irqreturn_t cppi_interrupt(int irq, void *dev_id)
         /* write to CPPI EOI register to re-enable interrupts */
         musb_writel(tibase, DAVINCI_CPPI_EOI_REG, 0);
 
+        if (cppi->irq)
+                spin_unlock_irqrestore(&musb->lock, flags);
+
         return IRQ_HANDLED;
 }
 
@@ -1406,15 +1418,6 @@ static int cppi_channel_abort(struct dma_channel *channel)
 
         if (cppi_ch->transmit) {
                 struct cppi_tx_stateram __iomem *tx_ram;
-                int                     enabled;
-
-                /* mask interrupts raised to signal teardown complete.  */
-                enabled = musb_readl(tibase, DAVINCI_TXCPPI_INTENAB_REG)
-                                & (1 << cppi_ch->index);
-                if (enabled)
-                        musb_writel(tibase, DAVINCI_TXCPPI_INTCLR_REG,
-                                        (1 << cppi_ch->index));
-
                 /* REVISIT put timeouts on these controller handshakes */
 
                 cppi_dump_tx(6, cppi_ch, " (teardown)");
@@ -1429,7 +1432,6 @@ static int cppi_channel_abort(struct dma_channel *channel)
                 do {
                         value = musb_readl(&tx_ram->tx_complete, 0);
                 } while (0xFFFFFFFC != value);
-                musb_writel(&tx_ram->tx_complete, 0, 0xFFFFFFFC);
 
                 /* FIXME clean up the transfer state ... here?
                  * the completion routine should get called with
@@ -1442,23 +1444,15 @@ static int cppi_channel_abort(struct dma_channel *channel)
                 musb_writew(regs, MUSB_TXCSR, value);
                 musb_writew(regs, MUSB_TXCSR, value);
 
-                /* While we scrub the TX state RAM, ensure that we clean
-                 * up any interrupt that's currently asserted:
+                /*
                  * 1. Write to completion Ptr value 0x1(bit 0 set)
                  *    (write back mode)
-                 * 2. Write to completion Ptr value 0x0(bit 0 cleared)
-                 *    (compare mode)
-                 * Value written is compared(for bits 31:2) and when
-                 * equal, interrupt is deasserted.
+                 * 2. Wait for abort interrupt and then put the channel in
+                 *    compare mode by writing 1 to the tx_complete register.
                  */
                 cppi_reset_tx(tx_ram, 1);
-                musb_writel(&tx_ram->tx_complete, 0, 0);
-
-                /* re-enable interrupt */
-                if (enabled)
-                        musb_writel(tibase, DAVINCI_TXCPPI_INTENAB_REG,
-                                        (1 << cppi_ch->index));
-
+                cppi_ch->head = 0;
+                musb_writel(&tx_ram->tx_complete, 0, 1);
                 cppi_dump_tx(5, cppi_ch, " (done teardown)");
 
                 /* REVISIT tx side _should_ clean up the same way
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index e16ff605c458..ce2e16fee0df 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -24,7 +24,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/delay.h>
@@ -42,7 +41,7 @@
 #include "musb_core.h"
 
 #ifdef CONFIG_MACH_DAVINCI_EVM
-#define GPIO_nVBUS_DRV          144
+#define GPIO_nVBUS_DRV          160
 #endif
 
 #include "davinci.h"
@@ -274,7 +273,7 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci)
         /* NOTE: DaVinci shadows the Mentor IRQs.  Don't manage them through
          * the Mentor registers (except for setup), use the TI ones and EOI.
          *
-         * Docs describe irq "vector" registers asociated with the CPPI and
+         * Docs describe irq "vector" registers associated with the CPPI and
          * USB EOI registers.  These hold a bitmask corresponding to the
          * current IRQ, not an irq handler address.  Would using those bits
          * resolve some of the races observed in this dispatch code??
@@ -445,6 +444,8 @@ int __init musb_platform_init(struct musb *musb)
         return 0;
 
 fail:
+        clk_disable(musb->clock);
+
         usb_nop_xceiv_unregister();
         return -ENODEV;
 }
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 547e0e390726..705cc4ad8737 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -379,7 +379,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                 u8 devctl, u8 power)
 {
         irqreturn_t handled = IRQ_NONE;
-        void __iomem *mbase = musb->mregs;
 
         DBG(3, "<== Power=%02x, DevCtl=%02x, int_usb=0x%x\n", power, devctl,
                 int_usb);
@@ -394,6 +393,8 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 
                 if (devctl & MUSB_DEVCTL_HM) {
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
+                        void __iomem *mbase = musb->mregs;
+
                         switch (musb->xceiv->state) {
                         case OTG_STATE_A_SUSPEND:
                                 /* remote wakeup?  later, GetPortStatus
@@ -471,6 +472,8 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
         /* see manual for the order of the tests */
         if (int_usb & MUSB_INTR_SESSREQ) {
+                void __iomem *mbase = musb->mregs;
+
                 DBG(1, "SESSION_REQUEST (%s)\n", otg_state_string(musb));
 
                 /* IRQ arrives from ID pin sense or (later, if VBUS power
@@ -519,6 +522,8 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 case OTG_STATE_A_WAIT_BCON:
                 case OTG_STATE_A_WAIT_VRISE:
                         if (musb->vbuserr_retry) {
+                                void __iomem *mbase = musb->mregs;
+
                                 musb->vbuserr_retry--;
                                 ignore = 1;
                                 devctl |= MUSB_DEVCTL_SESSION;
@@ -557,8 +562,72 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 handled = IRQ_HANDLED;
         }
 
+
+        if (int_usb & MUSB_INTR_SUSPEND) {
+                DBG(1, "SUSPEND (%s) devctl %02x power %02x\n",
+                                otg_state_string(musb), devctl, power);
+                handled = IRQ_HANDLED;
+
+                switch (musb->xceiv->state) {
+#ifdef  CONFIG_USB_MUSB_OTG
+                case OTG_STATE_A_PERIPHERAL:
+                        /* We also come here if the cable is removed, since
+                         * this silicon doesn't report ID-no-longer-grounded.
+                         *
+                         * We depend on T(a_wait_bcon) to shut us down, and
+                         * hope users don't do anything dicey during this
+                         * undesired detour through A_WAIT_BCON.
+                         */
+                        musb_hnp_stop(musb);
+                        usb_hcd_resume_root_hub(musb_to_hcd(musb));
+                        musb_root_disconnect(musb);
+                        musb_platform_try_idle(musb, jiffies
+                                        + msecs_to_jiffies(musb->a_wait_bcon
+                                                ? : OTG_TIME_A_WAIT_BCON));
+
+                        break;
+#endif
+                case OTG_STATE_B_IDLE:
+                        if (!musb->is_active)
+                                break;
+                case OTG_STATE_B_PERIPHERAL:
+                        musb_g_suspend(musb);
+                        musb->is_active = is_otg_enabled(musb)
+                                        && musb->xceiv->gadget->b_hnp_enable;
+                        if (musb->is_active) {
+#ifdef  CONFIG_USB_MUSB_OTG
+                                musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
+                                DBG(1, "HNP: Setting timer for b_ase0_brst\n");
+                                mod_timer(&musb->otg_timer, jiffies
+                                        + msecs_to_jiffies(
+                                                        OTG_TIME_B_ASE0_BRST));
+#endif
+                        }
+                        break;
+                case OTG_STATE_A_WAIT_BCON:
+                        if (musb->a_wait_bcon != 0)
+                                musb_platform_try_idle(musb, jiffies
+                                        + msecs_to_jiffies(musb->a_wait_bcon));
+                        break;
+                case OTG_STATE_A_HOST:
+                        musb->xceiv->state = OTG_STATE_A_SUSPEND;
+                        musb->is_active = is_otg_enabled(musb)
+                                        && musb->xceiv->host->b_hnp_enable;
+                        break;
+                case OTG_STATE_B_HOST:
+                        /* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
+                        DBG(1, "REVISIT: SUSPEND as B_HOST\n");
+                        break;
+                default:
+                        /* "should not happen" */
+                        musb->is_active = 0;
+                        break;
+                }
+        }
+
         if (int_usb & MUSB_INTR_CONNECT) {
                 struct usb_hcd *hcd = musb_to_hcd(musb);
+                void __iomem *mbase = musb->mregs;
 
                 handled = IRQ_HANDLED;
                 musb->is_active = 1;
@@ -625,10 +694,61 @@ b_host:
         }
 #endif  /* CONFIG_USB_MUSB_HDRC_HCD */
 
+        if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) {
+                DBG(1, "DISCONNECT (%s) as %s, devctl %02x\n",
+                                otg_state_string(musb),
+                                MUSB_MODE(musb), devctl);
+                handled = IRQ_HANDLED;
+
+                switch (musb->xceiv->state) {
+#ifdef CONFIG_USB_MUSB_HDRC_HCD
+                case OTG_STATE_A_HOST:
+                case OTG_STATE_A_SUSPEND:
+                        usb_hcd_resume_root_hub(musb_to_hcd(musb));
+                        musb_root_disconnect(musb);
+                        if (musb->a_wait_bcon != 0 && is_otg_enabled(musb))
+                                musb_platform_try_idle(musb, jiffies
+                                        + msecs_to_jiffies(musb->a_wait_bcon));
+                        break;
+#endif  /* HOST */
+#ifdef CONFIG_USB_MUSB_OTG
+                case OTG_STATE_B_HOST:
+                        /* REVISIT this behaves for "real disconnect"
+                         * cases; make sure the other transitions from
+                         * from B_HOST act right too.  The B_HOST code
+                         * in hnp_stop() is currently not used...
+                         */
+                        musb_root_disconnect(musb);
+                        musb_to_hcd(musb)->self.is_b_host = 0;
+                        musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
+                        MUSB_DEV_MODE(musb);
+                        musb_g_disconnect(musb);
+                        break;
+                case OTG_STATE_A_PERIPHERAL:
+                        musb_hnp_stop(musb);
+                        musb_root_disconnect(musb);
+                        /* FALLTHROUGH */
+                case OTG_STATE_B_WAIT_ACON:
+                        /* FALLTHROUGH */
+#endif  /* OTG */
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
+                case OTG_STATE_B_PERIPHERAL:
+                case OTG_STATE_B_IDLE:
+                        musb_g_disconnect(musb);
+                        break;
+#endif  /* GADGET */
+                default:
+                        WARNING("unhandled DISCONNECT transition (%s)\n",
+                                otg_state_string(musb));
+                        break;
+                }
+        }
+
         /* mentor saves a bit: bus reset and babble share the same irq.
          * only host sees babble; only peripheral sees bus reset.
          */
         if (int_usb & MUSB_INTR_RESET) {
+                handled = IRQ_HANDLED;
                 if (is_host_capable() && (devctl & MUSB_DEVCTL_HM) != 0) {
                         /*
                          * Looks like non-HS BABBLE can be ignored, but
@@ -641,7 +761,7 @@ b_host:
                                 DBG(1, "BABBLE devctl: %02x\n", devctl);
                         else {
                                 ERR("Stopping host session -- babble\n");
-                                musb_writeb(mbase, MUSB_DEVCTL, 0);
+                                musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
                         }
                 } else if (is_peripheral_capable()) {
                         DBG(1, "BUS RESET as %s\n", otg_state_string(musb));
@@ -686,29 +806,7 @@ b_host:
                                         otg_state_string(musb));
                         }
                 }
-
-                handled = IRQ_HANDLED;
         }
-        schedule_work(&musb->irq_work);
-
-        return handled;
-}
-
-/*
- * Interrupt Service Routine to record USB "global" interrupts.
- * Since these do not happen often and signify things of
- * paramount importance, it seems OK to check them individually;
- * the order of the tests is specified in the manual
- *
- * @param musb instance pointer
- * @param int_usb register contents
- * @param devctl
- * @param power
- */
-static irqreturn_t musb_stage2_irq(struct musb *musb, u8 int_usb,
-                                u8 devctl, u8 power)
-{
-        irqreturn_t handled = IRQ_NONE;
 
 #if 0
 /* REVISIT ... this would be for multiplexing periodic endpoints, or
@@ -755,117 +853,7 @@ static irqreturn_t musb_stage2_irq(struct musb *musb, u8 int_usb,
         }
 #endif
 
-        if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) {
-                DBG(1, "DISCONNECT (%s) as %s, devctl %02x\n",
-                                otg_state_string(musb),
-                                MUSB_MODE(musb), devctl);
-                handled = IRQ_HANDLED;
-
-                switch (musb->xceiv->state) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-                case OTG_STATE_A_HOST:
-                case OTG_STATE_A_SUSPEND:
-                        usb_hcd_resume_root_hub(musb_to_hcd(musb));
-                        musb_root_disconnect(musb);
-                        if (musb->a_wait_bcon != 0 && is_otg_enabled(musb))
-                                musb_platform_try_idle(musb, jiffies
-                                        + msecs_to_jiffies(musb->a_wait_bcon));
-                        break;
-#endif  /* HOST */
-#ifdef CONFIG_USB_MUSB_OTG
-                case OTG_STATE_B_HOST:
-                        /* REVISIT this behaves for "real disconnect"
-                         * cases; make sure the other transitions from
-                         * from B_HOST act right too.  The B_HOST code
-                         * in hnp_stop() is currently not used...
-                         */
-                        musb_root_disconnect(musb);
-                        musb_to_hcd(musb)->self.is_b_host = 0;
-                        musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
-                        MUSB_DEV_MODE(musb);
-                        musb_g_disconnect(musb);
-                        break;
-                case OTG_STATE_A_PERIPHERAL:
-                        musb_hnp_stop(musb);
-                        musb_root_disconnect(musb);
-                        /* FALLTHROUGH */
-                case OTG_STATE_B_WAIT_ACON:
-                        /* FALLTHROUGH */
-#endif  /* OTG */
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-                case OTG_STATE_B_PERIPHERAL:
-                case OTG_STATE_B_IDLE:
-                        musb_g_disconnect(musb);
-                        break;
-#endif  /* GADGET */
-                default:
-                        WARNING("unhandled DISCONNECT transition (%s)\n",
-                                otg_state_string(musb));
-                        break;
-                }
-
-                schedule_work(&musb->irq_work);
-        }
-
-        if (int_usb & MUSB_INTR_SUSPEND) {
-                DBG(1, "SUSPEND (%s) devctl %02x power %02x\n",
-                                otg_state_string(musb), devctl, power);
-                handled = IRQ_HANDLED;
-
-                switch (musb->xceiv->state) {
-#ifdef  CONFIG_USB_MUSB_OTG
-                case OTG_STATE_A_PERIPHERAL:
-                        /* We also come here if the cable is removed, since
-                         * this silicon doesn't report ID-no-longer-grounded.
-                         *
-                         * We depend on T(a_wait_bcon) to shut us down, and
-                         * hope users don't do anything dicey during this
-                         * undesired detour through A_WAIT_BCON.
-                         */
-                        musb_hnp_stop(musb);
-                        usb_hcd_resume_root_hub(musb_to_hcd(musb));
-                        musb_root_disconnect(musb);
-                        musb_platform_try_idle(musb, jiffies
-                                        + msecs_to_jiffies(musb->a_wait_bcon
-                                                ? : OTG_TIME_A_WAIT_BCON));
-                        break;
-#endif
-                case OTG_STATE_B_PERIPHERAL:
-                        musb_g_suspend(musb);
-                        musb->is_active = is_otg_enabled(musb)
-                                        && musb->xceiv->gadget->b_hnp_enable;
-                        if (musb->is_active) {
-#ifdef  CONFIG_USB_MUSB_OTG
-                                musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
-                                DBG(1, "HNP: Setting timer for b_ase0_brst\n");
-                                mod_timer(&musb->otg_timer, jiffies
-                                        + msecs_to_jiffies(
-                                                        OTG_TIME_B_ASE0_BRST));
-#endif
-                        }
-                        break;
-                case OTG_STATE_A_WAIT_BCON:
-                        if (musb->a_wait_bcon != 0)
-                                musb_platform_try_idle(musb, jiffies
-                                        + msecs_to_jiffies(musb->a_wait_bcon));
-                        break;
-                case OTG_STATE_A_HOST:
-                        musb->xceiv->state = OTG_STATE_A_SUSPEND;
-                        musb->is_active = is_otg_enabled(musb)
-                                        && musb->xceiv->host->b_hnp_enable;
-                        break;
-                case OTG_STATE_B_HOST:
-                        /* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
-                        DBG(1, "REVISIT: SUSPEND as B_HOST\n");
-                        break;
-                default:
-                        /* "should not happen" */
-                        musb->is_active = 0;
-                        break;
-                }
-                schedule_work(&musb->irq_work);
-        }
-
+        schedule_work(&musb->irq_work);
 
         return handled;
 }
@@ -977,10 +965,8 @@ static void musb_shutdown(struct platform_device *pdev)
         spin_lock_irqsave(&musb->lock, flags);
         musb_platform_disable(musb);
         musb_generic_disable(musb);
-        if (musb->clock) {
+        if (musb->clock)
                 clk_put(musb->clock);
-                musb->clock = NULL;
-        }
         spin_unlock_irqrestore(&musb->lock, flags);
 
         /* FIXME power down */
@@ -1000,7 +986,7 @@ static void musb_shutdown(struct platform_device *pdev)
  * more than selecting one of a bunch of predefined configurations.
  */
 #if defined(CONFIG_USB_TUSB6010) || \
-        defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP34XX)
+        defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3)
 static ushort __initdata fifo_mode = 4;
 #else
 static ushort __initdata fifo_mode = 2;
@@ -1095,6 +1081,36 @@ static struct fifo_cfg __initdata mode_4_cfg[] = {
 { .hw_ep_num = 15, .style = FIFO_RXTX, .maxpacket = 1024, },
 };
 
+/* mode 5 - fits in 8KB */
+static struct fifo_cfg __initdata mode_5_cfg[] = {
+{ .hw_ep_num =  1, .style = FIFO_TX,   .maxpacket = 512, },
+{ .hw_ep_num =  1, .style = FIFO_RX,   .maxpacket = 512, },
+{ .hw_ep_num =  2, .style = FIFO_TX,   .maxpacket = 512, },
+{ .hw_ep_num =  2, .style = FIFO_RX,   .maxpacket = 512, },
+{ .hw_ep_num =  3, .style = FIFO_TX,   .maxpacket = 512, },
+{ .hw_ep_num =  3, .style = FIFO_RX,   .maxpacket = 512, },
+{ .hw_ep_num =  4, .style = FIFO_TX,   .maxpacket = 512, },
+{ .hw_ep_num =  4, .style = FIFO_RX,   .maxpacket = 512, },
+{ .hw_ep_num =  5, .style = FIFO_TX,   .maxpacket = 512, },
+{ .hw_ep_num =  5, .style = FIFO_RX,   .maxpacket = 512, },
+{ .hw_ep_num =  6, .style = FIFO_TX,   .maxpacket = 32, },
+{ .hw_ep_num =  6, .style = FIFO_RX,   .maxpacket = 32, },
+{ .hw_ep_num =  7, .style = FIFO_TX,   .maxpacket = 32, },
+{ .hw_ep_num =  7, .style = FIFO_RX,   .maxpacket = 32, },
+{ .hw_ep_num =  8, .style = FIFO_TX,   .maxpacket = 32, },
+{ .hw_ep_num =  8, .style = FIFO_RX,   .maxpacket = 32, },
+{ .hw_ep_num =  9, .style = FIFO_TX,   .maxpacket = 32, },
+{ .hw_ep_num =  9, .style = FIFO_RX,   .maxpacket = 32, },
+{ .hw_ep_num = 10, .style = FIFO_TX,   .maxpacket = 32, },
+{ .hw_ep_num = 10, .style = FIFO_RX,   .maxpacket = 32, },
+{ .hw_ep_num = 11, .style = FIFO_TX,   .maxpacket = 32, },
+{ .hw_ep_num = 11, .style = FIFO_RX,   .maxpacket = 32, },
+{ .hw_ep_num = 12, .style = FIFO_TX,   .maxpacket = 32, },
+{ .hw_ep_num = 12, .style = FIFO_RX,   .maxpacket = 32, },
+{ .hw_ep_num = 13, .style = FIFO_RXTX, .maxpacket = 512, },
+{ .hw_ep_num = 14, .style = FIFO_RXTX, .maxpacket = 1024, },
+{ .hw_ep_num = 15, .style = FIFO_RXTX, .maxpacket = 1024, },
+};
 
 /*
  * configure a fifo; for non-shared endpoints, this may be called
@@ -1210,6 +1226,10 @@ static int __init ep_config_from_table(struct musb *musb)
                 cfg = mode_4_cfg;
                 n = ARRAY_SIZE(mode_4_cfg);
                 break;
+        case 5:
+                cfg = mode_5_cfg;
+                n = ARRAY_SIZE(mode_5_cfg);
+                break;
         }
 
         printk(KERN_DEBUG "%s: setup fifo_mode %d\n",
@@ -1314,13 +1334,9 @@ enum { MUSB_CONTROLLER_MHDRC, MUSB_CONTROLLER_HDRC, };
  */
 static int __init musb_core_init(u16 musb_type, struct musb *musb)
 {
-#ifdef MUSB_AHB_ID
-        u32 data;
-#endif
         u8 reg;
         char *type;
-        u16 hwvers, rev_major, rev_minor;
-        char aInfo[78], aRevision[32], aDate[12];
+        char aInfo[90], aRevision[32], aDate[12];
         void __iomem    *mbase = musb->mregs;
         int             status = 0;
         int             i;
@@ -1329,23 +1345,17 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
         reg = musb_read_configdata(mbase);
 
         strcpy(aInfo, (reg & MUSB_CONFIGDATA_UTMIDW) ? "UTMI-16" : "UTMI-8");
-        if (reg & MUSB_CONFIGDATA_DYNFIFO)
+        if (reg & MUSB_CONFIGDATA_DYNFIFO) {
                 strcat(aInfo, ", dyn FIFOs");
+                musb->dyn_fifo = true;
+        }
         if (reg & MUSB_CONFIGDATA_MPRXE) {
                 strcat(aInfo, ", bulk combine");
-#ifdef C_MP_RX
                 musb->bulk_combine = true;
-#else
-                strcat(aInfo, " (X)");          /* no driver support */
-#endif
         }
         if (reg & MUSB_CONFIGDATA_MPTXE) {
                 strcat(aInfo, ", bulk split");
-#ifdef C_MP_TX
                 musb->bulk_split = true;
-#else
-                strcat(aInfo, " (X)");          /* no driver support */
-#endif
         }
         if (reg & MUSB_CONFIGDATA_HBRXE) {
                 strcat(aInfo, ", HB-ISO Rx");
@@ -1361,20 +1371,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
         printk(KERN_DEBUG "%s: ConfigData=0x%02x (%s)\n",
                         musb_driver_name, reg, aInfo);
 
-#ifdef MUSB_AHB_ID
-        data = musb_readl(mbase, 0x404);
-        sprintf(aDate, "%04d-%02x-%02x", (data & 0xffff),
-                (data >> 16) & 0xff, (data >> 24) & 0xff);
-        /* FIXME ID2 and ID3 are unused */
-        data = musb_readl(mbase, 0x408);
-        printk(KERN_DEBUG "ID2=%lx\n", (long unsigned)data);
-        data = musb_readl(mbase, 0x40c);
-        printk(KERN_DEBUG "ID3=%lx\n", (long unsigned)data);
-        reg = musb_readb(mbase, 0x400);
-        musb_type = ('M' == reg) ? MUSB_CONTROLLER_MHDRC : MUSB_CONTROLLER_HDRC;
-#else
         aDate[0] = 0;
-#endif
         if (MUSB_CONTROLLER_MHDRC == musb_type) {
                 musb->is_multipoint = 1;
                 type = "M";
@@ -1391,11 +1388,10 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
         }
 
         /* log release info */
-        hwvers = musb_read_hwvers(mbase);
-        rev_major = (hwvers >> 10) & 0x1f;
-        rev_minor = hwvers & 0x3ff;
-        snprintf(aRevision, 32, "%d.%d%s", rev_major,
-                rev_minor, (hwvers & 0x8000) ? "RC" : "");
+        musb->hwvers = musb_read_hwvers(mbase);
+        snprintf(aRevision, 32, "%d.%d%s", MUSB_HWVERS_MAJOR(musb->hwvers),
+                MUSB_HWVERS_MINOR(musb->hwvers),
+                (musb->hwvers & MUSB_HWVERS_RC) ? "RC" : "");
         printk(KERN_DEBUG "%s: %sHDRC RTL version %s %s\n",
                         musb_driver_name, type, aRevision, aDate);
 
@@ -1406,21 +1402,10 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
         musb->nr_endpoints = 1;
         musb->epmask = 1;
 
-        if (reg & MUSB_CONFIGDATA_DYNFIFO) {
-                if (musb->config->dyn_fifo)
-                        status = ep_config_from_table(musb);
-                else {
-                        ERR("reconfigure software for Dynamic FIFOs\n");
-                        status = -ENODEV;
-                }
-        } else {
-                if (!musb->config->dyn_fifo)
-                        status = ep_config_from_hw(musb);
-                else {
-                        ERR("reconfigure software for static FIFOs\n");
-                        return -ENODEV;
-                }
-        }
+        if (musb->dyn_fifo)
+                status = ep_config_from_table(musb);
+        else
+                status = ep_config_from_hw(musb);
 
         if (status < 0)
                 return status;
@@ -1523,6 +1508,14 @@ irqreturn_t musb_interrupt(struct musb *musb)
                 (devctl & MUSB_DEVCTL_HM) ? "host" : "peripheral",
                 musb->int_usb, musb->int_tx, musb->int_rx);
 
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
+        if (is_otg_enabled(musb) || is_peripheral_enabled(musb))
+                if (!musb->gadget_driver) {
+                        DBG(5, "No gadget driver loaded\n");
+                        return IRQ_HANDLED;
+                }
+#endif
+
         /* the core can interrupt us for multiple reasons; docs have
          * a generic interrupt flowchart to follow
          */
@@ -1581,11 +1574,6 @@ irqreturn_t musb_interrupt(struct musb *musb)
                 ep_num++;
         }
 
-        /* finish handling "global" interrupts after handling fifos */
-        if (musb->int_usb)
-                retval |= musb_stage2_irq(musb,
-                                musb->int_usb, devctl, power);
-
         return retval;
 }
 
@@ -1690,7 +1678,7 @@ musb_vbus_store(struct device *dev, struct device_attribute *attr,
         unsigned long   val;
 
         if (sscanf(buf, "%lu", &val) < 1) {
-                printk(KERN_ERR "Invalid VBUS timeout ms value\n");
+                dev_err(dev, "Invalid VBUS timeout ms value\n");
                 return -EINVAL;
         }
 
@@ -1740,7 +1728,7 @@ musb_srp_store(struct device *dev, struct device_attribute *attr,
 
         if (sscanf(buf, "%hu", &srp) != 1
                         || (srp != 1)) {
-                printk(KERN_ERR "SRP: Value must be 1\n");
+                dev_err(dev, "SRP: Value must be 1\n");
                 return -EINVAL;
         }
 
@@ -1753,6 +1741,19 @@ static DEVICE_ATTR(srp, 0644, NULL, musb_srp_store);
 
 #endif /* CONFIG_USB_GADGET_MUSB_HDRC */
 
+static struct attribute *musb_attributes[] = {
+        &dev_attr_mode.attr,
+        &dev_attr_vbus.attr,
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
+        &dev_attr_srp.attr,
+#endif
+        NULL
+};
+
+static const struct attribute_group musb_attr_group = {
+        .attrs = musb_attributes,
+};
+
 #endif  /* sysfs */
 
 /* Only used to provide driver mode change events */
@@ -1827,11 +1828,7 @@ static void musb_free(struct musb *musb)
          */
 
 #ifdef CONFIG_SYSFS
-        device_remove_file(musb->controller, &dev_attr_mode);
-        device_remove_file(musb->controller, &dev_attr_vbus);
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-        device_remove_file(musb->controller, &dev_attr_srp);
-#endif
+        sysfs_remove_group(&musb->controller->kobj, &musb_attr_group);
 #endif
 
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
@@ -1854,15 +1851,6 @@ static void musb_free(struct musb *musb)
         put_device(musb->xceiv->dev);
 #endif
 
-        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
-        musb_platform_exit(musb);
-        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
-
-        if (musb->clock) {
-                clk_disable(musb->clock);
-                clk_put(musb->clock);
-        }
-
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
         usb_put_hcd(musb_to_hcd(musb));
 #else
@@ -1890,8 +1878,10 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
          */
         if (!plat) {
                 dev_dbg(dev, "no platform_data?\n");
-                return -ENODEV;
+                status = -ENODEV;
+                goto fail0;
         }
+
         switch (plat->mode) {
         case MUSB_HOST:
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
@@ -1913,13 +1903,16 @@ bad_config:
 #endif
         default:
                 dev_err(dev, "incompatible Kconfig role setting\n");
-                return -EINVAL;
+                status = -EINVAL;
+                goto fail0;
         }
 
         /* allocate */
         musb = allocate_instance(dev, plat->config, ctrl);
-        if (!musb)
-                return -ENOMEM;
+        if (!musb) {
+                status = -ENOMEM;
+                goto fail0;
+        }
 
         spin_lock_init(&musb->lock);
         musb->board_mode = plat->mode;
@@ -1937,7 +1930,7 @@ bad_config:
                 if (IS_ERR(musb->clock)) {
                         status = PTR_ERR(musb->clock);
                         musb->clock = NULL;
-                        goto fail;
+                        goto fail1;
                 }
         }
 
@@ -1956,12 +1949,12 @@ bad_config:
          */
         musb->isr = generic_interrupt;
         status = musb_platform_init(musb);
-
         if (status < 0)
-                goto fail;
+                goto fail2;
+
         if (!musb->isr) {
                 status = -ENODEV;
-                goto fail2;
+                goto fail3;
         }
 
 #ifndef CONFIG_MUSB_PIO_ONLY
@@ -1987,7 +1980,7 @@ bad_config:
                         ? MUSB_CONTROLLER_MHDRC
                         : MUSB_CONTROLLER_HDRC, musb);
         if (status < 0)
-                goto fail2;
+                goto fail3;
 
 #ifdef CONFIG_USB_MUSB_OTG
         setup_timer(&musb->otg_timer, musb_otg_timer_func, (unsigned long) musb);
@@ -2000,7 +1993,7 @@ bad_config:
         if (request_irq(nIrq, musb->isr, 0, dev_name(dev), musb)) {
                 dev_err(dev, "request_irq %d failed!\n", nIrq);
                 status = -ENODEV;
-                goto fail2;
+                goto fail3;
         }
         musb->nIrq = nIrq;
 /* FIXME this handles wakeup irqs wrong */
@@ -2011,19 +2004,6 @@ bad_config:
                 musb->irq_wake = 0;
         }
 
-        pr_info("%s: USB %s mode controller at %p using %s, IRQ %d\n",
-                        musb_driver_name,
-                        ({char *s;
-                        switch (musb->board_mode) {
-                        case MUSB_HOST:         s = "Host"; break;
-                        case MUSB_PERIPHERAL:   s = "Peripheral"; break;
-                        default:                s = "OTG"; break;
-                        }; s; }),
-                        ctrl,
-                        (is_dma_capable() && musb->dma_controller)
-                                ? "DMA" : "PIO",
-                        musb->nIrq);
-
         /* host side needs more setup */
         if (is_host_enabled(musb)) {
                 struct usb_hcd  *hcd = musb_to_hcd(musb);
@@ -2034,6 +2014,13 @@ bad_config:
                         hcd->self.otg_port = 1;
                 musb->xceiv->host = &hcd->self;
                 hcd->power_budget = 2 * (plat->power ? : 250);
+
+                /* program PHY to use external vBus if required */
+                if (plat->extvbus) {
+                        u8 busctl = musb_read_ulpi_buscontrol(musb->mregs);
+                        busctl |= MUSB_ULPI_USE_EXTVBUS;
+                        musb_write_ulpi_buscontrol(musb->mregs, busctl);
+                }
         }
 
         /* For the host-only role, we can activate right away.
@@ -2046,8 +2033,6 @@ bad_config:
                 musb->xceiv->state = OTG_STATE_A_IDLE;
 
                 status = usb_add_hcd(musb_to_hcd(musb), -1, 0);
-                if (status)
-                        goto fail;
 
                 DBG(1, "%s mode, status %d, devctl %02x %c\n",
                         "HOST", status,
@@ -2062,8 +2047,6 @@ bad_config:
                 musb->xceiv->state = OTG_STATE_B_IDLE;
 
                 status = musb_gadget_setup(musb);
-                if (status)
-                        goto fail;
 
                 DBG(1, "%s mode, status %d, dev%02x\n",
                         is_otg_enabled(musb) ? "OTG" : "PERIPHERAL",
@@ -2071,38 +2054,52 @@ bad_config:
                         musb_readb(musb->mregs, MUSB_DEVCTL));
 
         }
+        if (status < 0)
+                goto fail3;
 
 #ifdef CONFIG_SYSFS
-        status = device_create_file(dev, &dev_attr_mode);
-        status = device_create_file(dev, &dev_attr_vbus);
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-        status = device_create_file(dev, &dev_attr_srp);
-#endif /* CONFIG_USB_GADGET_MUSB_HDRC */
-        status = 0;
-#endif
+        status = sysfs_create_group(&musb->controller->kobj, &musb_attr_group);
         if (status)
-                goto fail2;
+                goto fail4;
+#endif
+
+        dev_info(dev, "USB %s mode controller at %p using %s, IRQ %d\n",
+                        ({char *s;
+                         switch (musb->board_mode) {
+                         case MUSB_HOST:                s = "Host"; break;
+                         case MUSB_PERIPHERAL:  s = "Peripheral"; break;
+                         default:               s = "OTG"; break;
+                         }; s; }),
+                        ctrl,
+                        (is_dma_capable() && musb->dma_controller)
+                        ? "DMA" : "PIO",
+                        musb->nIrq);
 
         return 0;
 
-fail2:
-#ifdef CONFIG_SYSFS
-        device_remove_file(musb->controller, &dev_attr_mode);
-        device_remove_file(musb->controller, &dev_attr_vbus);
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-        device_remove_file(musb->controller, &dev_attr_srp);
-#endif
-#endif
+fail4:
+        if (!is_otg_enabled(musb) && is_host_enabled(musb))
+                usb_remove_hcd(musb_to_hcd(musb));
+        else
+                musb_gadget_cleanup(musb);
+
+fail3:
+        if (musb->irq_wake)
+                device_init_wakeup(dev, 0);
         musb_platform_exit(musb);
-fail:
-        dev_err(musb->controller,
-                "musb_init_controller failed with status %d\n", status);
 
+fail2:
         if (musb->clock)
                 clk_put(musb->clock);
-        device_init_wakeup(dev, 0);
+
+fail1:
+        dev_err(musb->controller,
+                "musb_init_controller failed with status %d\n", status);
+
         musb_free(musb);
 
+fail0:
+
         return status;
 
 }
@@ -2121,6 +2118,7 @@ static int __init musb_probe(struct platform_device *pdev)
 {
         struct device   *dev = &pdev->dev;
         int             irq = platform_get_irq(pdev, 0);
+        int             status;
         struct resource *iomem;
         void __iomem    *base;
 
@@ -2128,7 +2126,7 @@ static int __init musb_probe(struct platform_device *pdev)
         if (!iomem || irq == 0)
                 return -ENODEV;
 
-        base = ioremap(iomem->start, iomem->end - iomem->start + 1);
+        base = ioremap(iomem->start, resource_size(iomem));
         if (!base) {
                 dev_err(dev, "ioremap failed\n");
                 return -ENOMEM;
@@ -2138,10 +2136,14 @@ static int __init musb_probe(struct platform_device *pdev)
         /* clobbered by use_dma=n */
         orig_dma_mask = dev->dma_mask;
 #endif
-        return musb_init_controller(dev, irq, base);
+        status = musb_init_controller(dev, irq, base);
+        if (status < 0)
+                iounmap(base);
+
+        return status;
 }
 
-static int __devexit musb_remove(struct platform_device *pdev)
+static int __exit musb_remove(struct platform_device *pdev)
 {
         struct musb     *musb = dev_to_musb(&pdev->dev);
         void __iomem    *ctrl_base = musb->ctrl_base;
@@ -2156,6 +2158,10 @@ static int __devexit musb_remove(struct platform_device *pdev)
         if (musb->board_mode == MUSB_HOST)
                 usb_remove_hcd(musb_to_hcd(musb));
 #endif
+        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
+        musb_platform_exit(musb);
+        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
+
         musb_free(musb);
         iounmap(ctrl_base);
         device_init_wakeup(&pdev->dev, 0);
@@ -2167,6 +2173,150 @@ static int __devexit musb_remove(struct platform_device *pdev)
 
 #ifdef  CONFIG_PM
 
+static struct musb_context_registers musb_context;
+
+void musb_save_context(struct musb *musb)
+{
+        int i;
+        void __iomem *musb_base = musb->mregs;
+
+        if (is_host_enabled(musb)) {
+                musb_context.frame = musb_readw(musb_base, MUSB_FRAME);
+                musb_context.testmode = musb_readb(musb_base, MUSB_TESTMODE);
+                musb_context.busctl = musb_read_ulpi_buscontrol(musb->mregs);
+        }
+        musb_context.power = musb_readb(musb_base, MUSB_POWER);
+        musb_context.intrtxe = musb_readw(musb_base, MUSB_INTRTXE);
+        musb_context.intrrxe = musb_readw(musb_base, MUSB_INTRRXE);
+        musb_context.intrusbe = musb_readb(musb_base, MUSB_INTRUSBE);
+        musb_context.index = musb_readb(musb_base, MUSB_INDEX);
+        musb_context.devctl = musb_readb(musb_base, MUSB_DEVCTL);
+
+        for (i = 0; i < MUSB_C_NUM_EPS; ++i) {
+                musb_writeb(musb_base, MUSB_INDEX, i);
+                musb_context.index_regs[i].txmaxp =
+                        musb_readw(musb_base, 0x10 + MUSB_TXMAXP);
+                musb_context.index_regs[i].txcsr =
+                        musb_readw(musb_base, 0x10 + MUSB_TXCSR);
+                musb_context.index_regs[i].rxmaxp =
+                        musb_readw(musb_base, 0x10 + MUSB_RXMAXP);
+                musb_context.index_regs[i].rxcsr =
+                        musb_readw(musb_base, 0x10 + MUSB_RXCSR);
+
+                if (musb->dyn_fifo) {
+                        musb_context.index_regs[i].txfifoadd =
+                                        musb_read_txfifoadd(musb_base);
+                        musb_context.index_regs[i].rxfifoadd =
+                                        musb_read_rxfifoadd(musb_base);
+                        musb_context.index_regs[i].txfifosz =
+                                        musb_read_txfifosz(musb_base);
+                        musb_context.index_regs[i].rxfifosz =
+                                        musb_read_rxfifosz(musb_base);
+                }
+                if (is_host_enabled(musb)) {
+                        musb_context.index_regs[i].txtype =
+                                musb_readb(musb_base, 0x10 + MUSB_TXTYPE);
+                        musb_context.index_regs[i].txinterval =
+                                musb_readb(musb_base, 0x10 + MUSB_TXINTERVAL);
+                        musb_context.index_regs[i].rxtype =
+                                musb_readb(musb_base, 0x10 + MUSB_RXTYPE);
+                        musb_context.index_regs[i].rxinterval =
+                                musb_readb(musb_base, 0x10 + MUSB_RXINTERVAL);
+
+                        musb_context.index_regs[i].txfunaddr =
+                                musb_read_txfunaddr(musb_base, i);
+                        musb_context.index_regs[i].txhubaddr =
+                                musb_read_txhubaddr(musb_base, i);
+                        musb_context.index_regs[i].txhubport =
+                                musb_read_txhubport(musb_base, i);
+
+                        musb_context.index_regs[i].rxfunaddr =
+                                musb_read_rxfunaddr(musb_base, i);
+                        musb_context.index_regs[i].rxhubaddr =
+                                musb_read_rxhubaddr(musb_base, i);
+                        musb_context.index_regs[i].rxhubport =
+                                musb_read_rxhubport(musb_base, i);
+                }
+        }
+
+        musb_writeb(musb_base, MUSB_INDEX, musb_context.index);
+
+        musb_platform_save_context(musb, &musb_context);
+}
+
+void musb_restore_context(struct musb *musb)
+{
+        int i;
+        void __iomem *musb_base = musb->mregs;
+        void __iomem *ep_target_regs;
+
+        musb_platform_restore_context(musb, &musb_context);
+
+        if (is_host_enabled(musb)) {
+                musb_writew(musb_base, MUSB_FRAME, musb_context.frame);
+                musb_writeb(musb_base, MUSB_TESTMODE, musb_context.testmode);
+                musb_write_ulpi_buscontrol(musb->mregs, musb_context.busctl);
+        }
+        musb_writeb(musb_base, MUSB_POWER, musb_context.power);
+        musb_writew(musb_base, MUSB_INTRTXE, musb_context.intrtxe);
+        musb_writew(musb_base, MUSB_INTRRXE, musb_context.intrrxe);
+        musb_writeb(musb_base, MUSB_INTRUSBE, musb_context.intrusbe);
+        musb_writeb(musb_base, MUSB_DEVCTL, musb_context.devctl);
+
+        for (i = 0; i < MUSB_C_NUM_EPS; ++i) {
+                musb_writeb(musb_base, MUSB_INDEX, i);
+                musb_writew(musb_base, 0x10 + MUSB_TXMAXP,
+                        musb_context.index_regs[i].txmaxp);
+                musb_writew(musb_base, 0x10 + MUSB_TXCSR,
+                        musb_context.index_regs[i].txcsr);
+                musb_writew(musb_base, 0x10 + MUSB_RXMAXP,
+                        musb_context.index_regs[i].rxmaxp);
+                musb_writew(musb_base, 0x10 + MUSB_RXCSR,
+                        musb_context.index_regs[i].rxcsr);
+
+                if (musb->dyn_fifo) {
+                        musb_write_txfifosz(musb_base,
+                                musb_context.index_regs[i].txfifosz);
+                        musb_write_rxfifosz(musb_base,
+                                musb_context.index_regs[i].rxfifosz);
+                        musb_write_txfifoadd(musb_base,
+                                musb_context.index_regs[i].txfifoadd);
+                        musb_write_rxfifoadd(musb_base,
+                                musb_context.index_regs[i].rxfifoadd);
+                }
+
+                if (is_host_enabled(musb)) {
+                        musb_writeb(musb_base, 0x10 + MUSB_TXTYPE,
+                                musb_context.index_regs[i].txtype);
+                        musb_writeb(musb_base, 0x10 + MUSB_TXINTERVAL,
+                                musb_context.index_regs[i].txinterval);
+                        musb_writeb(musb_base, 0x10 + MUSB_RXTYPE,
+                                musb_context.index_regs[i].rxtype);
+                        musb_writeb(musb_base, 0x10 + MUSB_RXINTERVAL,
+
+                        musb_context.index_regs[i].rxinterval);
+                        musb_write_txfunaddr(musb_base, i,
+                                musb_context.index_regs[i].txfunaddr);
+                        musb_write_txhubaddr(musb_base, i,
+                                musb_context.index_regs[i].txhubaddr);
+                        musb_write_txhubport(musb_base, i,
+                                musb_context.index_regs[i].txhubport);
+
+                        ep_target_regs =
+                                musb_read_target_reg_base(i, musb_base);
+
+                        musb_write_rxfunaddr(ep_target_regs,
+                                musb_context.index_regs[i].rxfunaddr);
+                        musb_write_rxhubaddr(ep_target_regs,
+                                musb_context.index_regs[i].rxhubaddr);
+                        musb_write_rxhubport(ep_target_regs,
+                                musb_context.index_regs[i].rxhubport);
+                }
+        }
+
+        musb_writeb(musb_base, MUSB_INDEX, musb_context.index);
+}
+
 static int musb_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
@@ -2188,6 +2338,8 @@ static int musb_suspend(struct device *dev)
                  */
         }
 
+        musb_save_context(musb);
+
         if (musb->set_clock)
                 musb->set_clock(musb->clock, 0);
         else
@@ -2209,6 +2361,8 @@ static int musb_resume_noirq(struct device *dev)
         else
                 clk_enable(musb->clock);
 
+        musb_restore_context(musb);
+
         /* for static cmos like DaVinci, register values were preserved
          * unless for some reason the whole soc powered down or the USB
          * module got reset through the PSC (vs just being disabled).
@@ -2216,7 +2370,7 @@ static int musb_resume_noirq(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops musb_dev_pm_ops = {
+static const struct dev_pm_ops musb_dev_pm_ops = {
         .suspend        = musb_suspend,
         .resume_noirq   = musb_resume_noirq,
 };
@@ -2233,7 +2387,7 @@ static struct platform_driver musb_driver = {
                 .owner          = THIS_MODULE,
                 .pm             = MUSB_DEV_PM_OPS,
         },
-        .remove         = __devexit_p(musb_remove),
+        .remove         = __exit_p(musb_remove),
         .shutdown       = musb_shutdown,
 };
 
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 6aa5f22e5274..ac17b004909b 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -52,6 +52,15 @@ struct musb;
 struct musb_hw_ep;
 struct musb_ep;
 
+/* Helper defines for struct musb->hwvers */
+#define MUSB_HWVERS_MAJOR(x)    ((x >> 10) & 0x1f)
+#define MUSB_HWVERS_MINOR(x)    (x & 0x3ff)
+#define MUSB_HWVERS_RC          0x8000
+#define MUSB_HWVERS_1300        0x52C
+#define MUSB_HWVERS_1400        0x590
+#define MUSB_HWVERS_1800        0x720
+#define MUSB_HWVERS_1900        0x784
+#define MUSB_HWVERS_2000        0x800
 
 #include "musb_debug.h"
 #include "musb_dma.h"
@@ -322,6 +331,7 @@ struct musb {
         struct clk              *clock;
         irqreturn_t             (*isr)(int, void *);
         struct work_struct      irq_work;
+        u16                     hwvers;
 
 /* this hub status bit is reserved by USB 2.0 and not seen by usbcore */
 #define MUSB_PORT_STAT_RESUME   (1 << 31)
@@ -403,22 +413,15 @@ struct musb {
 
         unsigned                hb_iso_rx:1;    /* high bandwidth iso rx? */
         unsigned                hb_iso_tx:1;    /* high bandwidth iso tx? */
+        unsigned                dyn_fifo:1;     /* dynamic FIFO supported? */
 
-#ifdef C_MP_TX
-        unsigned bulk_split:1;
+        unsigned                bulk_split:1;
 #define can_bulk_split(musb,type) \
-                (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_split)
-#else
-#define can_bulk_split(musb, type)      0
-#endif
+        (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_split)
 
-#ifdef C_MP_RX
-        unsigned bulk_combine:1;
+        unsigned                bulk_combine:1;
 #define can_bulk_combine(musb,type) \
-                (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_combine)
-#else
-#define can_bulk_combine(musb, type)    0
-#endif
+        (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_combine)
 
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
         /* is_suspended means USB B_PERIPHERAL suspend */
@@ -453,6 +456,45 @@ struct musb {
 #endif
 };
 
+#ifdef CONFIG_PM
+struct musb_csr_regs {
+        /* FIFO registers */
+        u16 txmaxp, txcsr, rxmaxp, rxcsr;
+        u16 rxfifoadd, txfifoadd;
+        u8 txtype, txinterval, rxtype, rxinterval;
+        u8 rxfifosz, txfifosz;
+        u8 txfunaddr, txhubaddr, txhubport;
+        u8 rxfunaddr, rxhubaddr, rxhubport;
+};
+
+struct musb_context_registers {
+
+#ifdef CONFIG_PM
+        u32 otg_sysconfig, otg_forcestandby;
+#endif
+        u8 power;
+        u16 intrtxe, intrrxe;
+        u8 intrusbe;
+        u16 frame;
+        u8 index, testmode;
+
+        u8 devctl, busctl, misc;
+
+        struct musb_csr_regs index_regs[MUSB_C_NUM_EPS];
+};
+
+#ifdef CONFIG_PM
+extern void musb_platform_save_context(struct musb *musb,
+                struct musb_context_registers *musb_context);
+extern void musb_platform_restore_context(struct musb *musb,
+                struct musb_context_registers *musb_context);
+#else
+#define musb_platform_save_context(m, x)        do {} while (0)
+#define musb_platform_restore_context(m, x)     do {} while (0)
+#endif
+
+#endif
+
 static inline void musb_set_vbus(struct musb *musb, int is_on)
 {
         musb->board_set_vbus(musb, is_on);
@@ -554,7 +596,7 @@ extern void musb_hnp_stop(struct musb *musb);
 extern int musb_platform_set_mode(struct musb *musb, u8 musb_mode);
 
 #if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN) || \
-        defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP34XX)
+        defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3)
 extern void musb_platform_try_idle(struct musb *musb, unsigned long timeout);
 #else
 #define musb_platform_try_idle(x, y)            do {} while (0)
diff --git a/drivers/usb/musb/musb_dma.h b/drivers/usb/musb/musb_dma.h
index 0a2c4e3602c1..916065ba9e70 100644
--- a/drivers/usb/musb/musb_dma.h
+++ b/drivers/usb/musb/musb_dma.h
@@ -80,6 +80,17 @@ struct musb_hw_ep;
 #define tusb_dma_omap()                 0
 #endif
 
+/* Anomaly 05000456 - USB Receive Interrupt Is Not Generated in DMA Mode 1
+ *      Only allow DMA mode 1 to be used when the USB will actually generate the
+ *      interrupts we expect.
+ */
+#ifdef CONFIG_BLACKFIN
+# undef USE_MODE1
+# if !ANOMALY_05000456
+#  define USE_MODE1
+# endif
+#endif
+
 /*
  * DMA channel status ... updated by the dma controller driver whenever that
  * status changes, and protected by the overall controller spinlock.
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 74073f9a43f0..6fca870e957e 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -43,6 +43,7 @@
 #include <linux/moduleparam.h>
 #include <linux/stat.h>
 #include <linux/dma-mapping.h>
+#include <linux/slab.h>
 
 #include "musb_core.h"
 
@@ -309,7 +310,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
                         size_t request_size;
 
                         /* setup DMA, then program endpoint CSR */
-                        request_size = min(request->length,
+                        request_size = min_t(size_t, request->length,
                                                 musb_ep->dma->max_len);
                         if (request_size < musb_ep->packet_sz)
                                 musb_ep->dma->desired_mode = 0;
@@ -319,7 +320,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
                         use_dma = use_dma && c->channel_program(
                                         musb_ep->dma, musb_ep->packet_sz,
                                         musb_ep->dma->desired_mode,
-                                        request->dma, request_size);
+                                        request->dma + request->actual, request_size);
                         if (use_dma) {
                                 if (musb_ep->dma->desired_mode == 0) {
                                         /*
@@ -429,112 +430,102 @@ void musb_g_tx(struct musb *musb, u8 epnum)
         DBG(4, "<== %s, txcsr %04x\n", musb_ep->end_point.name, csr);
 
         dma = is_dma_capable() ? musb_ep->dma : NULL;
-        do {
-                /* REVISIT for high bandwidth, MUSB_TXCSR_P_INCOMPTX
-                 * probably rates reporting as a host error
+
+        /*
+         * REVISIT: for high bandwidth, MUSB_TXCSR_P_INCOMPTX
+         * probably rates reporting as a host error.
+         */
+        if (csr & MUSB_TXCSR_P_SENTSTALL) {
+                csr |=  MUSB_TXCSR_P_WZC_BITS;
+                csr &= ~MUSB_TXCSR_P_SENTSTALL;
+                musb_writew(epio, MUSB_TXCSR, csr);
+                return;
+        }
+
+        if (csr & MUSB_TXCSR_P_UNDERRUN) {
+                /* We NAKed, no big deal... little reason to care. */
+                csr |=   MUSB_TXCSR_P_WZC_BITS;
+                csr &= ~(MUSB_TXCSR_P_UNDERRUN | MUSB_TXCSR_TXPKTRDY);
+                musb_writew(epio, MUSB_TXCSR, csr);
+                DBG(20, "underrun on ep%d, req %p\n", epnum, request);
+        }
+
+        if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
+                /*
+                 * SHOULD NOT HAPPEN... has with CPPI though, after
+                 * changing SENDSTALL (and other cases); harmless?
                  */
-                if (csr & MUSB_TXCSR_P_SENTSTALL) {
-                        csr |= MUSB_TXCSR_P_WZC_BITS;
-                        csr &= ~MUSB_TXCSR_P_SENTSTALL;
-                        musb_writew(epio, MUSB_TXCSR, csr);
-                        break;
-                }
+                DBG(5, "%s dma still busy?\n", musb_ep->end_point.name);
+                return;
+        }
+
+        if (request) {
+                u8      is_dma = 0;
 
-                if (csr & MUSB_TXCSR_P_UNDERRUN) {
-                        /* we NAKed, no big deal ... little reason to care */
+                if (dma && (csr & MUSB_TXCSR_DMAENAB)) {
+                        is_dma = 1;
                         csr |= MUSB_TXCSR_P_WZC_BITS;
-                        csr &= ~(MUSB_TXCSR_P_UNDERRUN
-                                        | MUSB_TXCSR_TXPKTRDY);
+                        csr &= ~(MUSB_TXCSR_DMAENAB | MUSB_TXCSR_P_UNDERRUN |
+                                 MUSB_TXCSR_TXPKTRDY);
                         musb_writew(epio, MUSB_TXCSR, csr);
-                        DBG(20, "underrun on ep%d, req %p\n", epnum, request);
+                        /* Ensure writebuffer is empty. */
+                        csr = musb_readw(epio, MUSB_TXCSR);
+                        request->actual += musb_ep->dma->actual_len;
+                        DBG(4, "TXCSR%d %04x, DMA off, len %zu, req %p\n",
+                                epnum, csr, musb_ep->dma->actual_len, request);
                 }
 
-                if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
-                        /* SHOULD NOT HAPPEN ... has with cppi though, after
-                         * changing SENDSTALL (and other cases); harmless?
+                if (is_dma || request->actual == request->length) {
+                        /*
+                         * First, maybe a terminating short packet. Some DMA
+                         * engines might handle this by themselves.
                          */
-                        DBG(5, "%s dma still busy?\n", musb_ep->end_point.name);
-                        break;
-                }
-
-                if (request) {
-                        u8      is_dma = 0;
+                        if ((request->zero && request->length
+                                && request->length % musb_ep->packet_sz == 0)
+#ifdef CONFIG_USB_INVENTRA_DMA
+                                || (is_dma && (!dma->desired_mode ||
+                                        (request->actual &
+                                                (musb_ep->packet_sz - 1))))
+#endif
+                        ) {
+                                /*
+                                 * On DMA completion, FIFO may not be
+                                 * available yet...
+                                 */
+                                if (csr & MUSB_TXCSR_TXPKTRDY)
+                                        return;
 
-                        if (dma && (csr & MUSB_TXCSR_DMAENAB)) {
-                                is_dma = 1;
-                                csr |= MUSB_TXCSR_P_WZC_BITS;
-                                csr &= ~(MUSB_TXCSR_DMAENAB
-                                                | MUSB_TXCSR_P_UNDERRUN
+                                DBG(4, "sending zero pkt\n");
+                                musb_writew(epio, MUSB_TXCSR, MUSB_TXCSR_MODE
                                                 | MUSB_TXCSR_TXPKTRDY);
-                                musb_writew(epio, MUSB_TXCSR, csr);
-                                /* ensure writebuffer is empty */
-                                csr = musb_readw(epio, MUSB_TXCSR);
-                                request->actual += musb_ep->dma->actual_len;
-                                DBG(4, "TXCSR%d %04x, dma off, "
-                                                "len %zu, req %p\n",
-                                        epnum, csr,
-                                        musb_ep->dma->actual_len,
-                                        request);
+                                request->zero = 0;
                         }
 
-                        if (is_dma || request->actual == request->length) {
-
-                                /* First, maybe a terminating short packet.
-                                 * Some DMA engines might handle this by
-                                 * themselves.
-                                 */
-                                if ((request->zero
-                                                && request->length
-                                                && (request->length
-                                                        % musb_ep->packet_sz)
-                                                        == 0)
-#ifdef CONFIG_USB_INVENTRA_DMA
-                                        || (is_dma &&
-                                                ((!dma->desired_mode) ||
-                                                    (request->actual &
-                                                    (musb_ep->packet_sz - 1))))
-#endif
-                                ) {
-                                        /* on dma completion, fifo may not
-                                         * be available yet ...
-                                         */
-                                        if (csr & MUSB_TXCSR_TXPKTRDY)
-                                                break;
-
-                                        DBG(4, "sending zero pkt\n");
-                                        musb_writew(epio, MUSB_TXCSR,
-                                                        MUSB_TXCSR_MODE
-                                                        | MUSB_TXCSR_TXPKTRDY);
-                                        request->zero = 0;
-                                }
-
-                                /* ... or if not, then complete it */
-                                musb_g_giveback(musb_ep, request, 0);
+                        /* ... or if not, then complete it. */
+                        musb_g_giveback(musb_ep, request, 0);
 
-                                /* kickstart next transfer if appropriate;
-                                 * the packet that just completed might not
-                                 * be transmitted for hours or days.
-                                 * REVISIT for double buffering...
-                                 * FIXME revisit for stalls too...
-                                 */
-                                musb_ep_select(mbase, epnum);
-                                csr = musb_readw(epio, MUSB_TXCSR);
-                                if (csr & MUSB_TXCSR_FIFONOTEMPTY)
-                                        break;
-                                request = musb_ep->desc
-                                                ? next_request(musb_ep)
-                                                : NULL;
-                                if (!request) {
-                                        DBG(4, "%s idle now\n",
-                                                musb_ep->end_point.name);
-                                        break;
-                                }
+                        /*
+                         * Kickstart next transfer if appropriate;
+                         * the packet that just completed might not
+                         * be transmitted for hours or days.
+                         * REVISIT for double buffering...
+                         * FIXME revisit for stalls too...
+                         */
+                        musb_ep_select(mbase, epnum);
+                        csr = musb_readw(epio, MUSB_TXCSR);
+                        if (csr & MUSB_TXCSR_FIFONOTEMPTY)
+                                return;
+
+                        request = musb_ep->desc ? next_request(musb_ep) : NULL;
+                        if (!request) {
+                                DBG(4, "%s idle now\n",
+                                        musb_ep->end_point.name);
+                                return;
                         }
-
-                        txstate(musb, to_musb_request(request));
                 }
 
-        } while (0);
+                txstate(musb, to_musb_request(request));
+        }
 }
 
 /* ------------------------------------------------------------ */
@@ -756,6 +747,8 @@ void musb_g_rx(struct musb *musb, u8 epnum)
         musb_ep_select(mbase, epnum);
 
         request = next_request(musb_ep);
+        if (!request)
+                return;
 
         csr = musb_readw(epio, MUSB_RXCSR);
         dma = is_dma_capable() ? musb_ep->dma : NULL;
@@ -903,7 +896,14 @@ static int musb_gadget_enable(struct usb_ep *ep,
                 /* REVISIT if can_bulk_split(), use by updating "tmp";
                  * likewise high bandwidth periodic tx
                  */
-                musb_writew(regs, MUSB_TXMAXP, tmp);
+                /* Set TXMAXP with the FIFO size of the endpoint
+                 * to disable double buffering mode. Currently, It seems that double
+                 * buffering has problem if musb RTL revision number < 2.0.
+                 */
+                if (musb->hwvers < MUSB_HWVERS_2000)
+                        musb_writew(regs, MUSB_TXMAXP, hw_ep->max_packet_sz_tx);
+                else
+                        musb_writew(regs, MUSB_TXMAXP, tmp);
 
                 csr = MUSB_TXCSR_MODE | MUSB_TXCSR_CLRDATATOG;
                 if (musb_readw(regs, MUSB_TXCSR)
@@ -933,7 +933,13 @@ static int musb_gadget_enable(struct usb_ep *ep,
                 /* REVISIT if can_bulk_combine() use by updating "tmp"
                  * likewise high bandwidth periodic rx
                  */
-                musb_writew(regs, MUSB_RXMAXP, tmp);
+                /* Set RXMAXP with the FIFO size of the endpoint
+                 * to disable double buffering mode.
+                 */
+                if (musb->hwvers < MUSB_HWVERS_2000)
+                        musb_writew(regs, MUSB_RXMAXP, hw_ep->max_packet_sz_rx);
+                else
+                        musb_writew(regs, MUSB_RXMAXP, tmp);
 
                 /* force shared fifo to OUT-only mode */
                 if (hw_ep->is_shared_fifo) {
@@ -966,6 +972,7 @@ static int musb_gadget_enable(struct usb_ep *ep,
 
         musb_ep->desc = desc;
         musb_ep->busy = 0;
+        musb_ep->wedged = 0;
         status = 0;
 
         pr_debug("%s periph: enabled %s for %s %s, %smaxpacket %d\n",
@@ -1220,7 +1227,7 @@ done:
  *
  * exported to ep0 code
  */
-int musb_gadget_set_halt(struct usb_ep *ep, int value)
+static int musb_gadget_set_halt(struct usb_ep *ep, int value)
 {
         struct musb_ep          *musb_ep = to_musb_ep(ep);
         u8                      epnum = musb_ep->current_epnum;
@@ -1262,7 +1269,8 @@ int musb_gadget_set_halt(struct usb_ep *ep, int value)
                                 goto done;
                         }
                 }
-        }
+        } else
+                musb_ep->wedged = 0;
 
         /* set/clear the stall and toggle bits */
         DBG(2, "%s: %s stall\n", ep->name, value ? "set" : "clear");
@@ -1301,6 +1309,21 @@ done:
         return status;
 }
 
+/*
+ * Sets the halt feature with the clear requests ignored
+ */
+static int musb_gadget_set_wedge(struct usb_ep *ep)
+{
+        struct musb_ep          *musb_ep = to_musb_ep(ep);
+
+        if (!ep)
+                return -EINVAL;
+
+        musb_ep->wedged = 1;
+
+        return usb_ep_set_halt(ep);
+}
+
 static int musb_gadget_fifo_status(struct usb_ep *ep)
 {
         struct musb_ep          *musb_ep = to_musb_ep(ep);
@@ -1371,6 +1394,7 @@ static const struct usb_ep_ops musb_ep_ops = {
         .queue          = musb_gadget_queue,
         .dequeue        = musb_gadget_dequeue,
         .set_halt       = musb_gadget_set_halt,
+        .set_wedge      = musb_gadget_set_wedge,
         .fifo_status    = musb_gadget_fifo_status,
         .fifo_flush     = musb_gadget_fifo_flush
 };
@@ -1687,8 +1711,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 return -EINVAL;
 
         /* driver must be initialized to support peripheral mode */
-        if (!musb || !(musb->board_mode == MUSB_OTG
-                                || musb->board_mode != MUSB_OTG)) {
+        if (!musb) {
                 DBG(1, "%s, no dev??\n", __func__);
                 return -ENODEV;
         }
@@ -1723,6 +1746,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 spin_lock_irqsave(&musb->lock, flags);
 
                 otg_set_peripheral(musb->xceiv, &musb->g);
+                musb->xceiv->state = OTG_STATE_B_IDLE;
                 musb->is_active = 1;
 
                 /* FIXME this ignores the softconnect flag.  Drivers are
diff --git a/drivers/usb/musb/musb_gadget.h b/drivers/usb/musb/musb_gadget.h
index 59502da9f739..c8b140325d82 100644
--- a/drivers/usb/musb/musb_gadget.h
+++ b/drivers/usb/musb/musb_gadget.h
@@ -75,6 +75,8 @@ struct musb_ep {
         /* later things are modified based on usage */
         struct list_head                req_list;
 
+        u8                              wedged;
+
         /* true if lock must be dropped but req_list may not be advanced */
         u8                              busy;
 };
@@ -103,6 +105,4 @@ extern void musb_gadget_cleanup(struct musb *);
 
 extern void musb_g_giveback(struct musb_ep *, struct usb_request *, int);
 
-extern int musb_gadget_set_halt(struct usb_ep *ep, int value);
-
 #endif          /* __MUSB_GADGET_H */
diff --git a/drivers/usb/musb/musb_gadget_ep0.c b/drivers/usb/musb/musb_gadget_ep0.c
index 522efb31b56b..53d06451f820 100644
--- a/drivers/usb/musb/musb_gadget_ep0.c
+++ b/drivers/usb/musb/musb_gadget_ep0.c
@@ -199,7 +199,6 @@ service_in_request(struct musb *musb, const struct usb_ctrlrequest *ctrlrequest)
 static void musb_g_ep0_giveback(struct musb *musb, struct usb_request *req)
 {
         musb_g_giveback(&musb->endpoints[0].ep_in, req, 0);
-        musb->ep0_state = MUSB_EP0_STAGE_SETUP;
 }
 
 /*
@@ -258,30 +257,53 @@ __acquires(musb->lock)
                         case USB_RECIP_INTERFACE:
                                 break;
                         case USB_RECIP_ENDPOINT:{
-                                const u8 num = ctrlrequest->wIndex & 0x0f;
-                                struct musb_ep *musb_ep;
+                                const u8                epnum =
+                                        ctrlrequest->wIndex & 0x0f;
+                                struct musb_ep          *musb_ep;
+                                struct musb_hw_ep       *ep;
+                                void __iomem            *regs;
+                                int                     is_in;
+                                u16                     csr;
 
-                                if (num == 0
-                                                || num >= MUSB_C_NUM_EPS
-                                                || ctrlrequest->wValue
-                                                        != USB_ENDPOINT_HALT)
+                                if (epnum == 0 || epnum >= MUSB_C_NUM_EPS ||
+                                    ctrlrequest->wValue != USB_ENDPOINT_HALT)
                                         break;
 
-                                if (ctrlrequest->wIndex & USB_DIR_IN)
-                                        musb_ep = &musb->endpoints[num].ep_in;
+                                ep = musb->endpoints + epnum;
+                                regs = ep->regs;
+                                is_in = ctrlrequest->wIndex & USB_DIR_IN;
+                                if (is_in)
+                                        musb_ep = &ep->ep_in;
                                 else
-                                        musb_ep = &musb->endpoints[num].ep_out;
+                                        musb_ep = &ep->ep_out;
                                 if (!musb_ep->desc)
                                         break;
 
-                                /* REVISIT do it directly, no locking games */
-                                spin_unlock(&musb->lock);
-                                musb_gadget_set_halt(&musb_ep->end_point, 0);
-                                spin_lock(&musb->lock);
+                                handled = 1;
+                                /* Ignore request if endpoint is wedged */
+                                if (musb_ep->wedged)
+                                        break;
+
+                                musb_ep_select(mbase, epnum);
+                                if (is_in) {
+                                        csr  = musb_readw(regs, MUSB_TXCSR);
+                                        csr |= MUSB_TXCSR_CLRDATATOG |
+                                               MUSB_TXCSR_P_WZC_BITS;
+                                        csr &= ~(MUSB_TXCSR_P_SENDSTALL |
+                                                 MUSB_TXCSR_P_SENTSTALL |
+                                                 MUSB_TXCSR_TXPKTRDY);
+                                        musb_writew(regs, MUSB_TXCSR, csr);
+                                } else {
+                                        csr  = musb_readw(regs, MUSB_RXCSR);
+                                        csr |= MUSB_RXCSR_CLRDATATOG |
+                                               MUSB_RXCSR_P_WZC_BITS;
+                                        csr &= ~(MUSB_RXCSR_P_SENDSTALL |
+                                                 MUSB_RXCSR_P_SENTSTALL);
+                                        musb_writew(regs, MUSB_RXCSR, csr);
+                                }
 
                                 /* select ep0 again */
                                 musb_ep_select(mbase, 0);
-                                handled = 1;
                                 } break;
                         default:
                                 /* class, vendor, etc ... delegate */
@@ -374,10 +396,8 @@ stall:
                                 int                     is_in;
                                 u16                     csr;
 
-                                if (epnum == 0
-                                                || epnum >= MUSB_C_NUM_EPS
-                                                || ctrlrequest->wValue
-                                                        != USB_ENDPOINT_HALT)
+                                if (epnum == 0 || epnum >= MUSB_C_NUM_EPS ||
+                                    ctrlrequest->wValue != USB_ENDPOINT_HALT)
                                         break;
 
                                 ep = musb->endpoints + epnum;
@@ -392,24 +412,20 @@ stall:
 
                                 musb_ep_select(mbase, epnum);
                                 if (is_in) {
-                                        csr = musb_readw(regs,
-                                                        MUSB_TXCSR);
+                                        csr = musb_readw(regs, MUSB_TXCSR);
                                         if (csr & MUSB_TXCSR_FIFONOTEMPTY)
                                                 csr |= MUSB_TXCSR_FLUSHFIFO;
                                         csr |= MUSB_TXCSR_P_SENDSTALL
                                                 | MUSB_TXCSR_CLRDATATOG
                                                 | MUSB_TXCSR_P_WZC_BITS;
-                                        musb_writew(regs, MUSB_TXCSR,
-                                                        csr);
+                                        musb_writew(regs, MUSB_TXCSR, csr);
                                 } else {
-                                        csr = musb_readw(regs,
-                                                        MUSB_RXCSR);
+                                        csr = musb_readw(regs, MUSB_RXCSR);
                                         csr |= MUSB_RXCSR_P_SENDSTALL
                                                 | MUSB_RXCSR_FLUSHFIFO
                                                 | MUSB_RXCSR_CLRDATATOG
                                                 | MUSB_RXCSR_P_WZC_BITS;
-                                        musb_writew(regs, MUSB_RXCSR,
-                                                        csr);
+                                        musb_writew(regs, MUSB_RXCSR, csr);
                                 }
 
                                 /* select ep0 again */
@@ -648,7 +664,7 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
                         musb->ep0_state = MUSB_EP0_STAGE_STATUSIN;
                         break;
                 default:
-                        ERR("SetupEnd came in a wrong ep0stage %s",
+                        ERR("SetupEnd came in a wrong ep0stage %s\n",
                             decode_ep0stage(musb->ep0_state));
                 }
                 csr = musb_readw(regs, MUSB_CSR0);
@@ -771,12 +787,18 @@ setup:
                                 handled = service_zero_data_request(
                                                 musb, &setup);
 
+                                /*
+                                 * We're expecting no data in any case, so
+                                 * always set the DATAEND bit -- doing this
+                                 * here helps avoid SetupEnd interrupt coming
+                                 * in the idle stage when we're stalling...
+                                 */
+                                musb->ackpend |= MUSB_CSR0_P_DATAEND;
+
                                 /* status stage might be immediate */
-                                if (handled > 0) {
-                                        musb->ackpend |= MUSB_CSR0_P_DATAEND;
+                                if (handled > 0)
                                         musb->ep0_state =
                                                 MUSB_EP0_STAGE_STATUSIN;
-                                }
                                 break;
 
                         /* sequence #1 (IN to host), includes GET_STATUS
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index e3ab40a966eb..877d20b1dff9 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -605,8 +605,14 @@ musb_rx_reinit(struct musb *musb, struct musb_qh *qh, struct musb_hw_ep *ep)
         musb_writeb(ep->regs, MUSB_RXTYPE, qh->type_reg);
         musb_writeb(ep->regs, MUSB_RXINTERVAL, qh->intv_reg);
         /* NOTE: bulk combining rewrites high bits of maxpacket */
-        musb_writew(ep->regs, MUSB_RXMAXP,
-                        qh->maxpacket | ((qh->hb_mult - 1) << 11));
+        /* Set RXMAXP with the FIFO size of the endpoint
+         * to disable double buffer mode.
+         */
+        if (musb->hwvers < MUSB_HWVERS_2000)
+                musb_writew(ep->regs, MUSB_RXMAXP, ep->max_packet_sz_rx);
+        else
+                musb_writew(ep->regs, MUSB_RXMAXP,
+                                qh->maxpacket | ((qh->hb_mult - 1) << 11));
 
         ep->rx_reinit = 0;
 }
@@ -1642,18 +1648,18 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                         c = musb->dma_controller;
 
                         if (usb_pipeisoc(pipe)) {
-                                int status = 0;
+                                int d_status = 0;
                                 struct usb_iso_packet_descriptor *d;
 
                                 d = urb->iso_frame_desc + qh->iso_idx;
 
                                 if (iso_err) {
-                                        status = -EILSEQ;
+                                        d_status = -EILSEQ;
                                         urb->error_count++;
                                 }
                                 if (rx_count > d->length) {
-                                        if (status == 0) {
-                                                status = -EOVERFLOW;
+                                        if (d_status == 0) {
+                                                d_status = -EOVERFLOW;
                                                 urb->error_count++;
                                         }
                                         DBG(2, "** OVERFLOW %d into %d\n",\
@@ -1662,7 +1668,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                                         length = d->length;
                                 } else
                                         length = rx_count;
-                                d->status = status;
+                                d->status = d_status;
                                 buf = urb->transfer_dma + d->offset;
                         } else {
                                 length = rx_count;
@@ -1683,7 +1689,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                                 dma->desired_mode = 1;
                         if (rx_count < hw_ep->max_packet_sz_rx) {
                                 length = rx_count;
-                                dma->bDesiredMode = 0;
+                                dma->desired_mode = 0;
                         } else {
                                 length = urb->transfer_buffer_length;
                         }
@@ -1771,6 +1777,9 @@ static int musb_schedule(
         int                     best_end, epnum;
         struct musb_hw_ep       *hw_ep = NULL;
         struct list_head        *head = NULL;
+        u8                      toggle;
+        u8                      txtype;
+        struct urb              *urb = next_urb(qh);
 
         /* use fixed hardware for control and bulk */
         if (qh->type == USB_ENDPOINT_XFER_CONTROL) {
@@ -1809,6 +1818,27 @@ static int musb_schedule(
                 diff -= (qh->maxpacket * qh->hb_mult);
 
                 if (diff >= 0 && best_diff > diff) {
+
+                        /*
+                         * Mentor controller has a bug in that if we schedule
+                         * a BULK Tx transfer on an endpoint that had earlier
+                         * handled ISOC then the BULK transfer has to start on
+                         * a zero toggle.  If the BULK transfer starts on a 1
+                         * toggle then this transfer will fail as the mentor
+                         * controller starts the Bulk transfer on a 0 toggle
+                         * irrespective of the programming of the toggle bits
+                         * in the TXCSR register.  Check for this condition
+                         * while allocating the EP for a Tx Bulk transfer.  If
+                         * so skip this EP.
+                         */
+                        hw_ep = musb->endpoints + epnum;
+                        toggle = usb_gettoggle(urb->dev, qh->epnum, !is_in);
+                        txtype = (musb_readb(hw_ep->regs, MUSB_TXTYPE)
+                                        >> 4) & 0x3;
+                        if (!is_in && (qh->type == USB_ENDPOINT_XFER_BULK) &&
+                                toggle && (txtype == USB_ENDPOINT_XFER_ISOC))
+                                continue;
+
                         best_diff = diff;
                         best_end = epnum;
                 }
@@ -2012,6 +2042,7 @@ static int musb_urb_enqueue(
                  * odd, rare, error prone, but legal.
                  */
                 kfree(qh);
+                qh = NULL;
                 ret = 0;
         } else
                 ret = musb_schedule(musb, qh,
diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index cc1d71b57d3c..fa55aacc385d 100644
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -72,6 +72,10 @@
 #define MUSB_DEVCTL_HR          0x02
 #define MUSB_DEVCTL_SESSION     0x01
 
+/* MUSB ULPI VBUSCONTROL */
+#define MUSB_ULPI_USE_EXTVBUS   0x01
+#define MUSB_ULPI_USE_EXTVBUSIND 0x02
+
 /* TESTMODE */
 #define MUSB_TEST_FORCE_HOST    0x80
 #define MUSB_TEST_FIFO_ACCESS   0x40
@@ -246,6 +250,7 @@
 
 /* REVISIT: vctrl/vstatus: optional vendor utmi+phy register at 0x68 */
 #define MUSB_HWVERS             0x6C    /* 8 bit */
+#define MUSB_ULPI_BUSCONTROL    0x70    /* 8 bit */
 
 #define MUSB_EPINFO             0x78    /* 8 bit */
 #define MUSB_RAMINFO            0x79    /* 8 bit */
@@ -321,6 +326,36 @@ static inline void  musb_write_rxfifoadd(void __iomem *mbase, u16 c_off)
         musb_writew(mbase, MUSB_RXFIFOADD, c_off);
 }
 
+static inline void musb_write_ulpi_buscontrol(void __iomem *mbase, u8 val)
+{
+        musb_writeb(mbase, MUSB_ULPI_BUSCONTROL, val);
+}
+
+static inline u8 musb_read_txfifosz(void __iomem *mbase)
+{
+        return musb_readb(mbase, MUSB_TXFIFOSZ);
+}
+
+static inline u16 musb_read_txfifoadd(void __iomem *mbase)
+{
+        return musb_readw(mbase, MUSB_TXFIFOADD);
+}
+
+static inline u8 musb_read_rxfifosz(void __iomem *mbase)
+{
+        return musb_readb(mbase, MUSB_RXFIFOSZ);
+}
+
+static inline u16  musb_read_rxfifoadd(void __iomem *mbase)
+{
+        return musb_readw(mbase, MUSB_RXFIFOADD);
+}
+
+static inline u8 musb_read_ulpi_buscontrol(void __iomem *mbase)
+{
+        return musb_readb(mbase, MUSB_ULPI_BUSCONTROL);
+}
+
 static inline u8 musb_read_configdata(void __iomem *mbase)
 {
         musb_writeb(mbase, MUSB_INDEX, 0);
@@ -376,6 +411,36 @@ static inline void  musb_write_txhubport(void __iomem *mbase, u8 epnum,
                         qh_h_port_reg);
 }
 
+static inline u8 musb_read_rxfunaddr(void __iomem *mbase, u8 epnum)
+{
+        return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_RXFUNCADDR));
+}
+
+static inline u8 musb_read_rxhubaddr(void __iomem *mbase, u8 epnum)
+{
+        return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_RXHUBADDR));
+}
+
+static inline u8 musb_read_rxhubport(void __iomem *mbase, u8 epnum)
+{
+        return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_RXHUBPORT));
+}
+
+static inline u8  musb_read_txfunaddr(void __iomem *mbase, u8 epnum)
+{
+        return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXFUNCADDR));
+}
+
+static inline u8  musb_read_txhubaddr(void __iomem *mbase, u8 epnum)
+{
+        return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBADDR));
+}
+
+static inline u8  musb_read_txhubport(void __iomem *mbase, u8 epnum)
+{
+        return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBPORT));
+}
+
 #else /* CONFIG_BLACKFIN */
 
 #define USB_BASE                USB_FADDR
@@ -436,7 +501,7 @@ static inline void  musb_write_txhubport(void __iomem *mbase, u8 epnum,
 #define MUSB_FLAT_OFFSET(_epnum, _offset)       \
         (USB_OFFSET(USB_EP_NI0_TXMAXP) + (0x40 * (_epnum)) + (_offset))
 
-/* Not implemented - HW has seperate Tx/Rx FIFO */
+/* Not implemented - HW has separate Tx/Rx FIFO */
 #define MUSB_TXCSR_MODE                 0x0000
 
 static inline void musb_write_txfifosz(void __iomem *mbase, u8 c_size)
@@ -455,21 +520,54 @@ static inline void  musb_write_rxfifoadd(void __iomem *mbase, u16 c_off)
 {
 }
 
-static inline u8 musb_read_configdata(void __iomem *mbase)
+static inline void musb_write_ulpi_buscontrol(void __iomem *mbase, u8 val)
+{
+}
+
+static inline u8 musb_read_txfifosz(void __iomem *mbase)
 {
         return 0;
 }
 
-static inline u16 musb_read_hwvers(void __iomem *mbase)
+static inline u16 musb_read_txfifoadd(void __iomem *mbase)
+{
+        return 0;
+}
+
+static inline u8 musb_read_rxfifosz(void __iomem *mbase)
+{
+        return 0;
+}
+
+static inline u16  musb_read_rxfifoadd(void __iomem *mbase)
+{
+        return 0;
+}
+
+static inline u8 musb_read_ulpi_buscontrol(void __iomem *mbase)
 {
         return 0;
 }
 
-static inline u16 musb_read_target_reg_base(u8 i, void __iomem *mbase)
+static inline u8 musb_read_configdata(void __iomem *mbase)
 {
         return 0;
 }
 
+static inline u16 musb_read_hwvers(void __iomem *mbase)
+{
+        /*
+         * This register is invisible on Blackfin, actually the MUSB
+         * RTL version of Blackfin is 1.9, so just harcode its value.
+         */
+        return MUSB_HWVERS_1900;
+}
+
+static inline void __iomem *musb_read_target_reg_base(u8 i, void __iomem *mbase)
+{
+        return NULL;
+}
+
 static inline void musb_write_rxfunaddr(void __iomem *ep_target_regs,
                 u8 qh_addr_req)
 {
@@ -500,6 +598,35 @@ static inline void  musb_write_txhubport(void __iomem *mbase, u8 epnum,
 {
 }
 
+static inline u8 musb_read_rxfunaddr(void __iomem *mbase, u8 epnum)
+{
+        return 0;
+}
+
+static inline u8 musb_read_rxhubaddr(void __iomem *mbase, u8 epnum)
+{
+        return 0;
+}
+
+static inline u8 musb_read_rxhubport(void __iomem *mbase, u8 epnum)
+{
+        return 0;
+}
+
+static inline u8  musb_read_txfunaddr(void __iomem *mbase, u8 epnum)
+{
+        return 0;
+}
+
+static inline u8  musb_read_txhubaddr(void __iomem *mbase, u8 epnum)
+{
+        return 0;
+}
+
+static inline void  musb_read_txhubport(void __iomem *mbase, u8 epnum)
+{
+}
+
 #endif /* CONFIG_BLACKFIN */
 
 #endif  /* __MUSB_REGS_H__ */
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index bfe5fe4ebfee..7775e1c0a215 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -35,7 +35,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/time.h>
diff --git a/drivers/usb/musb/musbhsdma.c b/drivers/usb/musb/musbhsdma.c
index 5e83f96d6b77..1008044a3bbc 100644
--- a/drivers/usb/musb/musbhsdma.c
+++ b/drivers/usb/musb/musbhsdma.c
@@ -33,6 +33,7 @@
 #include <linux/device.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include "musb_core.h"
 #include "musbhsdma.h"
 
@@ -250,14 +251,38 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
         u8 bchannel;
         u8 int_hsdma;
 
-        u32 addr;
+        u32 addr, count;
         u16 csr;
 
         spin_lock_irqsave(&musb->lock, flags);
 
         int_hsdma = musb_readb(mbase, MUSB_HSDMA_INTR);
-        if (!int_hsdma)
-                goto done;
+
+#ifdef CONFIG_BLACKFIN
+        /* Clear DMA interrupt flags */
+        musb_writeb(mbase, MUSB_HSDMA_INTR, int_hsdma);
+#endif
+
+        if (!int_hsdma) {
+                DBG(2, "spurious DMA irq\n");
+
+                for (bchannel = 0; bchannel < MUSB_HSDMA_CHANNELS; bchannel++) {
+                        musb_channel = (struct musb_dma_channel *)
+                                        &(controller->channel[bchannel]);
+                        channel = &musb_channel->channel;
+                        if (channel->status == MUSB_DMA_STATUS_BUSY) {
+                                count = musb_read_hsdma_count(mbase, bchannel);
+
+                                if (count == 0)
+                                        int_hsdma |= (1 << bchannel);
+                        }
+                }
+
+                DBG(2, "int_hsdma = 0x%x\n", int_hsdma);
+
+                if (!int_hsdma)
+                        goto done;
+        }
 
         for (bchannel = 0; bchannel < MUSB_HSDMA_CHANNELS; bchannel++) {
                 if (int_hsdma & (1 << bchannel)) {
@@ -280,7 +305,7 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
                                 channel->actual_len = addr
                                         - musb_channel->start_addr;
 
-                                DBG(2, "ch %p, 0x%x -> 0x%x (%d / %d) %s\n",
+                                DBG(2, "ch %p, 0x%x -> 0x%x (%zu / %d) %s\n",
                                         channel, musb_channel->start_addr,
                                         addr, channel->actual_len,
                                         musb_channel->len,
@@ -324,11 +349,6 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
                 }
         }
 
-#ifdef CONFIG_BLACKFIN
-        /* Clear DMA interrup flags */
-        musb_writeb(mbase, MUSB_HSDMA_INTR, int_hsdma);
-#endif
-
         retval = IRQ_HANDLED;
 done:
         spin_unlock_irqrestore(&musb->lock, flags);
diff --git a/drivers/usb/musb/musbhsdma.h b/drivers/usb/musb/musbhsdma.h
index 1299d92dc83f..613f95a058f7 100644
--- a/drivers/usb/musb/musbhsdma.h
+++ b/drivers/usb/musb/musbhsdma.h
@@ -55,6 +55,10 @@
                     MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDRESS), \
                     addr)
 
+#define musb_read_hsdma_count(mbase, bchannel)  \
+        musb_readl(mbase,       \
+                   MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT))
+
 #define musb_write_hsdma_count(mbase, bchannel, len) \
         musb_writel(mbase, \
                     MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT), \
@@ -96,6 +100,19 @@ static inline void musb_write_hsdma_addr(void __iomem *mbase,
                 ((u16)(((u32) dma_addr >> 16) & 0xFFFF)));
 }
 
+static inline u32 musb_read_hsdma_count(void __iomem *mbase, u8 bchannel)
+{
+        u32 count = musb_readw(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT_HIGH));
+
+        count = count << 16;
+
+        count |= musb_readw(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT_LOW));
+
+        return count;
+}
+
 static inline void musb_write_hsdma_count(void __iomem *mbase,
                                 u8 bchannel, u32 len)
 {
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index 34875201ee04..82592633502f 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -27,7 +27,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/clk.h>
@@ -35,7 +34,7 @@
 
 #include <asm/mach-types.h>
 #include <mach/hardware.h>
-#include <mach/mux.h>
+#include <plat/mux.h>
 
 #include "musb_core.h"
 #include "omap2430.h"
@@ -220,7 +219,7 @@ int __init musb_platform_init(struct musb *musb)
 
         musb_platform_resume(musb);
 
-        l = omap_readl(OTG_SYSCONFIG);
+        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
         l &= ~ENABLEWAKEUP;     /* disable wakeup */
         l &= ~NOSTDBY;          /* remove possible nostdby */
         l |= SMARTSTDBY;        /* enable smart standby */
@@ -233,17 +232,19 @@ int __init musb_platform_init(struct musb *musb)
          */
         if (!cpu_is_omap3430())
                 l |= AUTOIDLE;          /* enable auto idle */
-        omap_writel(l, OTG_SYSCONFIG);
+        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
 
-        l = omap_readl(OTG_INTERFSEL);
+        l = musb_readl(musb->mregs, OTG_INTERFSEL);
         l |= ULPI_12PIN;
-        omap_writel(l, OTG_INTERFSEL);
+        musb_writel(musb->mregs, OTG_INTERFSEL, l);
 
         pr_debug("HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
                         "sysstatus 0x%x, intrfsel 0x%x, simenable  0x%x\n",
-                        omap_readl(OTG_REVISION), omap_readl(OTG_SYSCONFIG),
-                        omap_readl(OTG_SYSSTATUS), omap_readl(OTG_INTERFSEL),
-                        omap_readl(OTG_SIMENABLE));
+                        musb_readl(musb->mregs, OTG_REVISION),
+                        musb_readl(musb->mregs, OTG_SYSCONFIG),
+                        musb_readl(musb->mregs, OTG_SYSSTATUS),
+                        musb_readl(musb->mregs, OTG_INTERFSEL),
+                        musb_readl(musb->mregs, OTG_SIMENABLE));
 
         omap_vbus_power(musb, musb->board_mode == MUSB_HOST, 1);
 
@@ -255,6 +256,22 @@ int __init musb_platform_init(struct musb *musb)
         return 0;
 }
 
+#ifdef CONFIG_PM
+void musb_platform_save_context(struct musb *musb,
+                struct musb_context_registers *musb_context)
+{
+        musb_context->otg_sysconfig = musb_readl(musb->mregs, OTG_SYSCONFIG);
+        musb_context->otg_forcestandby = musb_readl(musb->mregs, OTG_FORCESTDBY);
+}
+
+void musb_platform_restore_context(struct musb *musb,
+                struct musb_context_registers *musb_context)
+{
+        musb_writel(musb->mregs, OTG_SYSCONFIG, musb_context->otg_sysconfig);
+        musb_writel(musb->mregs, OTG_FORCESTDBY, musb_context->otg_forcestandby);
+}
+#endif
+
 int musb_platform_suspend(struct musb *musb)
 {
         u32 l;
@@ -263,13 +280,13 @@ int musb_platform_suspend(struct musb *musb)
                 return 0;
 
         /* in any role */
-        l = omap_readl(OTG_FORCESTDBY);
+        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
         l |= ENABLEFORCE;       /* enable MSTANDBY */
-        omap_writel(l, OTG_FORCESTDBY);
+        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
 
-        l = omap_readl(OTG_SYSCONFIG);
+        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
         l |= ENABLEWAKEUP;      /* enable wakeup */
-        omap_writel(l, OTG_SYSCONFIG);
+        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
 
         otg_set_suspend(musb->xceiv, 1);
 
@@ -295,13 +312,13 @@ static int musb_platform_resume(struct musb *musb)
         else
                 clk_enable(musb->clock);
 
-        l = omap_readl(OTG_SYSCONFIG);
+        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
         l &= ~ENABLEWAKEUP;     /* disable wakeup */
-        omap_writel(l, OTG_SYSCONFIG);
+        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
 
-        l = omap_readl(OTG_FORCESTDBY);
+        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
         l &= ~ENABLEFORCE;      /* disable MSTANDBY */
-        omap_writel(l, OTG_FORCESTDBY);
+        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
 
         return 0;
 }
@@ -314,8 +331,5 @@ int musb_platform_exit(struct musb *musb)
 
         musb_platform_suspend(musb);
 
-        clk_put(musb->clock);
-        musb->clock = 0;
-
         return 0;
 }
diff --git a/drivers/usb/musb/omap2430.h b/drivers/usb/musb/omap2430.h
index dc7670718cd2..40b3c02ae9f0 100644
--- a/drivers/usb/musb/omap2430.h
+++ b/drivers/usb/musb/omap2430.h
@@ -10,47 +10,43 @@
 #ifndef __MUSB_OMAP243X_H__
 #define __MUSB_OMAP243X_H__
 
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3430)
-#include <mach/hardware.h>
-#include <mach/usb.h>
+#include <plat/usb.h>
 
 /*
  * OMAP2430-specific definitions
  */
 
-#define MENTOR_BASE_OFFSET      0
-#if     defined(CONFIG_ARCH_OMAP2430)
-#define OMAP_HSOTG_BASE         (OMAP243X_HS_BASE)
-#elif   defined(CONFIG_ARCH_OMAP3430)
-#define OMAP_HSOTG_BASE         (OMAP34XX_HSUSB_OTG_BASE)
-#endif
-#define OMAP_HSOTG(offset)      (OMAP_HSOTG_BASE + 0x400 + (offset))
-#define OTG_REVISION            OMAP_HSOTG(0x0)
-#define OTG_SYSCONFIG           OMAP_HSOTG(0x4)
+#define OTG_REVISION            0x400
+
+#define OTG_SYSCONFIG           0x404
 #       define  MIDLEMODE       12      /* bit position */
 #       define  FORCESTDBY              (0 << MIDLEMODE)
 #       define  NOSTDBY                 (1 << MIDLEMODE)
 #       define  SMARTSTDBY              (2 << MIDLEMODE)
+
 #       define  SIDLEMODE               3       /* bit position */
 #       define  FORCEIDLE               (0 << SIDLEMODE)
 #       define  NOIDLE                  (1 << SIDLEMODE)
 #       define  SMARTIDLE               (2 << SIDLEMODE)
+
 #       define  ENABLEWAKEUP            (1 << 2)
 #       define  SOFTRST                 (1 << 1)
 #       define  AUTOIDLE                (1 << 0)
-#define OTG_SYSSTATUS           OMAP_HSOTG(0x8)
+
+#define OTG_SYSSTATUS           0x408
 #       define  RESETDONE               (1 << 0)
-#define OTG_INTERFSEL           OMAP_HSOTG(0xc)
+
+#define OTG_INTERFSEL           0x40c
 #       define  EXTCP                   (1 << 2)
-#       define  PHYSEL          0       /* bit position */
+#       define  PHYSEL                  0       /* bit position */
 #       define  UTMI_8BIT               (0 << PHYSEL)
 #       define  ULPI_12PIN              (1 << PHYSEL)
 #       define  ULPI_8PIN               (2 << PHYSEL)
-#define OTG_SIMENABLE           OMAP_HSOTG(0x10)
+
+#define OTG_SIMENABLE           0x410
 #       define  TM1                     (1 << 0)
-#define OTG_FORCESTDBY          OMAP_HSOTG(0x14)
-#       define  ENABLEFORCE             (1 << 0)
 
-#endif  /* CONFIG_ARCH_OMAP2430 */
+#define OTG_FORCESTDBY          0x414
+#       define  ENABLEFORCE             (1 << 0)
 
 #endif  /* __MUSB_OMAP243X_H__ */
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 88b587c703e9..60d3938cafcf 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -29,6 +29,19 @@ static void tusb_source_power(struct musb *musb, int is_on);
 #define TUSB_REV_MAJOR(reg_val)         ((reg_val >> 4) & 0xf)
 #define TUSB_REV_MINOR(reg_val)         (reg_val & 0xf)
 
+#ifdef CONFIG_PM
+/* REVISIT: These should be only needed if somebody implements off idle */
+void musb_platform_save_context(struct musb *musb,
+                        struct musb_context_registers *musb_context)
+{
+}
+
+void musb_platform_restore_context(struct musb *musb,
+                        struct musb_context_registers *musb_context)
+{
+}
+#endif
+
 /*
  * Checks the revision. We need to use the DMA register as 3.0 does not
  * have correct versions for TUSB_PRCM_REV or TUSB_INT_CTRL_REV.
@@ -1118,7 +1131,7 @@ int __init musb_platform_init(struct musb *musb)
         }
         musb->sync = mem->start;
 
-        sync = ioremap(mem->start, mem->end - mem->start + 1);
+        sync = ioremap(mem->start, resource_size(mem));
         if (!sync) {
                 pr_debug("ioremap for sync failed\n");
                 ret = -ENOMEM;
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index 7e073a0d7ac9..c061a88f2b0f 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -15,8 +15,9 @@
 #include <linux/usb.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <mach/dma.h>
-#include <mach/mux.h>
+#include <linux/slab.h>
+#include <plat/dma.h>
+#include <plat/mux.h>
 
 #include "musb_core.h"
 
@@ -38,7 +39,7 @@ struct tusb_omap_dma_ch {
 
         struct tusb_omap_dma    *tusb_dma;
 
-        void __iomem            *dma_addr;
+        dma_addr_t              dma_addr;
 
         u32                     len;
         u16                     packet_sz;
@@ -125,6 +126,7 @@ static void tusb_omap_dma_cb(int lch, u16 ch_status, void *data)
         struct tusb_omap_dma_ch *chdat = to_chdat(channel);
         struct tusb_omap_dma    *tusb_dma = chdat->tusb_dma;
         struct musb             *musb = chdat->musb;
+        struct device           *dev = musb->controller;
         struct musb_hw_ep       *hw_ep = chdat->hw_ep;
         void __iomem            *ep_conf = hw_ep->conf;
         void __iomem            *mbase = musb->mregs;
@@ -172,13 +174,15 @@ static void tusb_omap_dma_cb(int lch, u16 ch_status, void *data)
                 DBG(3, "Using PIO for remaining %lu bytes\n", pio);
                 buf = phys_to_virt((u32)chdat->dma_addr) + chdat->transfer_len;
                 if (chdat->tx) {
-                        dma_cache_maint(phys_to_virt((u32)chdat->dma_addr),
-                                        chdat->transfer_len, DMA_TO_DEVICE);
+                        dma_unmap_single(dev, chdat->dma_addr,
+                                                chdat->transfer_len,
+                                                DMA_TO_DEVICE);
                         musb_write_fifo(hw_ep, pio, buf);
                 } else {
+                        dma_unmap_single(dev, chdat->dma_addr,
+                                                chdat->transfer_len,
+                                                DMA_FROM_DEVICE);
                         musb_read_fifo(hw_ep, pio, buf);
-                        dma_cache_maint(phys_to_virt((u32)chdat->dma_addr),
-                                        chdat->transfer_len, DMA_FROM_DEVICE);
                 }
                 channel->actual_len += pio;
         }
@@ -223,6 +227,7 @@ static int tusb_omap_dma_program(struct dma_channel *channel, u16 packet_sz,
         struct tusb_omap_dma_ch         *chdat = to_chdat(channel);
         struct tusb_omap_dma            *tusb_dma = chdat->tusb_dma;
         struct musb                     *musb = chdat->musb;
+        struct device                   *dev = musb->controller;
         struct musb_hw_ep               *hw_ep = chdat->hw_ep;
         void __iomem                    *mbase = musb->mregs;
         void __iomem                    *ep_conf = hw_ep->conf;
@@ -298,14 +303,16 @@ static int tusb_omap_dma_program(struct dma_channel *channel, u16 packet_sz,
         chdat->packet_sz = packet_sz;
         chdat->len = len;
         channel->actual_len = 0;
-        chdat->dma_addr = (void __iomem *)dma_addr;
+        chdat->dma_addr = dma_addr;
         channel->status = MUSB_DMA_STATUS_BUSY;
 
         /* Since we're recycling dma areas, we need to clean or invalidate */
         if (chdat->tx)
-                dma_cache_maint(phys_to_virt(dma_addr), len, DMA_TO_DEVICE);
+                dma_map_single(dev, phys_to_virt(dma_addr), len,
+                                DMA_TO_DEVICE);
         else
-                dma_cache_maint(phys_to_virt(dma_addr), len, DMA_FROM_DEVICE);
+                dma_map_single(dev, phys_to_virt(dma_addr), len,
+                                DMA_FROM_DEVICE);
 
         /* Use 16-bit transfer if dma_addr is not 32-bit aligned */
         if ((dma_addr & 0x3) == 0) {
@@ -648,7 +655,7 @@ void dma_controller_destroy(struct dma_controller *c)
                 }
         }
 
-        if (!tusb_dma->multichannel && tusb_dma && tusb_dma->ch >= 0)
+        if (tusb_dma && !tusb_dma->multichannel && tusb_dma->ch >= 0)
                 omap_free_dma(tusb_dma->ch);
 
         kfree(tusb_dma);
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig
index aa884d072f0b..3d2d3e549bd1 100644
--- a/drivers/usb/otg/Kconfig
+++ b/drivers/usb/otg/Kconfig
@@ -41,6 +41,16 @@ config ISP1301_OMAP
           This driver can also be built as a module.  If so, the module
           will be called isp1301_omap.
 
+config USB_ULPI
+        bool "Generic ULPI Transceiver Driver"
+        depends on ARM
+        select USB_OTG_UTILS
+        help
+          Enable this to support ULPI connected USB OTG transceivers which
+          are likely found on embedded boards.
+
+          The only chip currently supported is NXP's ISP1504
+
 config TWL4030_USB
         tristate "TWL4030 USB Transceiver Driver"
         depends on TWL4030_CORE && REGULATOR_TWL4030
diff --git a/drivers/usb/otg/Makefile b/drivers/usb/otg/Makefile
index 208167856529..aeb49a8ec412 100644
--- a/drivers/usb/otg/Makefile
+++ b/drivers/usb/otg/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_USB_GPIO_VBUS)	+= gpio_vbus.o
 obj-$(CONFIG_ISP1301_OMAP)      += isp1301_omap.o
 obj-$(CONFIG_TWL4030_USB)       += twl4030-usb.o
 obj-$(CONFIG_NOP_USB_XCEIV)     += nop-usb-xceiv.o
+obj-$(CONFIG_USB_ULPI)          += ulpi.o
 
 ccflags-$(CONFIG_USB_DEBUG)     += -DDEBUG
 ccflags-$(CONFIG_USB_GADGET_DEBUG) += -DDEBUG
diff --git a/drivers/usb/otg/gpio_vbus.c b/drivers/usb/otg/gpio_vbus.c
index 1c26c94513e9..221c44444ec6 100644
--- a/drivers/usb/otg/gpio_vbus.c
+++ b/drivers/usb/otg/gpio_vbus.c
@@ -11,6 +11,7 @@
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/usb.h>
 #include <linux/workqueue.h>
diff --git a/drivers/usb/otg/isp1301_omap.c b/drivers/usb/otg/isp1301_omap.c
index 77a5f4188999..78a209709260 100644
--- a/drivers/usb/otg/isp1301_omap.c
+++ b/drivers/usb/otg/isp1301_omap.c
@@ -36,8 +36,8 @@
 #include <asm/irq.h>
 #include <asm/mach-types.h>
 
-#include <mach/usb.h>
-#include <mach/mux.h>
+#include <plat/usb.h>
+#include <plat/mux.h>
 
 
 #ifndef DEBUG
@@ -843,7 +843,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
 
 static struct platform_device *otg_dev;
 
-static int otg_init(struct isp1301 *isp)
+static int isp1301_otg_init(struct isp1301 *isp)
 {
         u32 l;
 
@@ -1275,7 +1275,7 @@ static int __exit isp1301_remove(struct i2c_client *i2c)
 static int isp1301_otg_enable(struct isp1301 *isp)
 {
         power_up(isp);
-        otg_init(isp);
+        isp1301_otg_init(isp);
 
         /* NOTE:  since we don't change this, this provides
          * a few more interrupts than are strictly needed.
diff --git a/drivers/usb/otg/nop-usb-xceiv.c b/drivers/usb/otg/nop-usb-xceiv.c
index af456b48985f..e70014ab0976 100644
--- a/drivers/usb/otg/nop-usb-xceiv.c
+++ b/drivers/usb/otg/nop-usb-xceiv.c
@@ -30,6 +30,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/usb/otg.h>
+#include <linux/slab.h>
 
 struct nop_usb_xceiv {
         struct otg_transceiver  otg;
diff --git a/drivers/usb/otg/twl4030-usb.c b/drivers/usb/otg/twl4030-usb.c
index 9e3e7a5c258b..223cdf46ccb7 100644
--- a/drivers/usb/otg/twl4030-usb.c
+++ b/drivers/usb/otg/twl4030-usb.c
@@ -33,10 +33,11 @@
 #include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/usb/otg.h>
-#include <linux/i2c/twl4030.h>
+#include <linux/i2c/twl.h>
 #include <linux/regulator/consumer.h>
 #include <linux/err.h>
-
+#include <linux/notifier.h>
+#include <linux/slab.h>
 
 /* Register defines */
 
@@ -236,15 +237,6 @@
 #define PMBR1                           0x0D
 #define GPIO_USB_4PIN_ULPI_2430C        (3 << 0)
 
-
-
-enum linkstat {
-        USB_LINK_UNKNOWN = 0,
-        USB_LINK_NONE,
-        USB_LINK_VBUS,
-        USB_LINK_ID,
-};
-
 struct twl4030_usb {
         struct otg_transceiver  otg;
         struct device           *dev;
@@ -276,16 +268,16 @@ static int twl4030_i2c_write_u8_verify(struct twl4030_usb *twl,
 {
         u8 check;
 
-        if ((twl4030_i2c_write_u8(module, data, address) >= 0) &&
-            (twl4030_i2c_read_u8(module, &check, address) >= 0) &&
+        if ((twl_i2c_write_u8(module, data, address) >= 0) &&
+            (twl_i2c_read_u8(module, &check, address) >= 0) &&
                                                 (check == data))
                 return 0;
         dev_dbg(twl->dev, "Write%d[%d,0x%x] wrote %02x but read %02x\n",
                         1, module, address, check, data);
 
         /* Failed once: Try again */
-        if ((twl4030_i2c_write_u8(module, data, address) >= 0) &&
-            (twl4030_i2c_read_u8(module, &check, address) >= 0) &&
+        if ((twl_i2c_write_u8(module, data, address) >= 0) &&
+            (twl_i2c_read_u8(module, &check, address) >= 0) &&
                                                 (check == data))
                 return 0;
         dev_dbg(twl->dev, "Write%d[%d,0x%x] wrote %02x but read %02x\n",
@@ -303,7 +295,7 @@ static inline int twl4030_usb_write(struct twl4030_usb *twl,
 {
         int ret = 0;
 
-        ret = twl4030_i2c_write_u8(TWL4030_MODULE_USB, data, address);
+        ret = twl_i2c_write_u8(TWL4030_MODULE_USB, data, address);
         if (ret < 0)
                 dev_dbg(twl->dev,
                         "TWL4030:USB:Write[0x%x] Error %d\n", address, ret);
@@ -315,7 +307,7 @@ static inline int twl4030_readb(struct twl4030_usb *twl, u8 module, u8 address)
         u8 data;
         int ret = 0;
 
-        ret = twl4030_i2c_read_u8(module, &data, address);
+        ret = twl_i2c_read_u8(module, &data, address);
         if (ret >= 0)
                 ret = data;
         else
@@ -347,10 +339,10 @@ twl4030_usb_clear_bits(struct twl4030_usb *twl, u8 reg, u8 bits)
 
 /*-------------------------------------------------------------------------*/
 
-static enum linkstat twl4030_usb_linkstat(struct twl4030_usb *twl)
+static enum usb_xceiv_events twl4030_usb_linkstat(struct twl4030_usb *twl)
 {
         int     status;
-        int     linkstat = USB_LINK_UNKNOWN;
+        int     linkstat = USB_EVENT_NONE;
 
         /*
          * For ID/VBUS sensing, see manual section 15.4.8 ...
@@ -368,11 +360,11 @@ static enum linkstat twl4030_usb_linkstat(struct twl4030_usb *twl)
                 dev_err(twl->dev, "USB link status err %d\n", status);
         else if (status & (BIT(7) | BIT(2))) {
                 if (status & BIT(2))
-                        linkstat = USB_LINK_ID;
+                        linkstat = USB_EVENT_ID;
                 else
-                        linkstat = USB_LINK_VBUS;
+                        linkstat = USB_EVENT_VBUS;
         } else
-                linkstat = USB_LINK_NONE;
+                linkstat = USB_EVENT_NONE;
 
         dev_dbg(twl->dev, "HW_CONDITIONS 0x%02x/%d; link %d\n",
                         status, status, linkstat);
@@ -383,7 +375,7 @@ static enum linkstat twl4030_usb_linkstat(struct twl4030_usb *twl)
 
         spin_lock_irq(&twl->lock);
         twl->linkstat = linkstat;
-        if (linkstat == USB_LINK_ID) {
+        if (linkstat == USB_EVENT_ID) {
                 twl->otg.default_a = true;
                 twl->otg.state = OTG_STATE_A_IDLE;
         } else {
@@ -462,7 +454,7 @@ static void twl4030_phy_power(struct twl4030_usb *twl, int on)
                  * SLEEP. We work around this by clearing the bit after usv3v1
                  * is re-activated. This ensures that VUSB3V1 is really active.
                  */
-                twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0,
+                twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0,
                                                         VUSB_DEDICATED2);
                 regulator_enable(twl->usb1v5);
                 pwr &= ~PHY_PWR_PHYPWD;
@@ -505,44 +497,44 @@ static void twl4030_phy_resume(struct twl4030_usb *twl)
 static int twl4030_usb_ldo_init(struct twl4030_usb *twl)
 {
         /* Enable writing to power configuration registers */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0xC0, PROTECT_KEY);
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0x0C, PROTECT_KEY);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0xC0, PROTECT_KEY);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0x0C, PROTECT_KEY);
 
         /* put VUSB3V1 LDO in active state */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB_DEDICATED2);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB_DEDICATED2);
 
         /* input to VUSB3V1 LDO is from VBAT, not VBUS */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x14, VUSB_DEDICATED1);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x14, VUSB_DEDICATED1);
 
         /* Initialize 3.1V regulator */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_DEV_GRP);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_DEV_GRP);
 
         twl->usb3v1 = regulator_get(twl->dev, "usb3v1");
         if (IS_ERR(twl->usb3v1))
                 return -ENODEV;
 
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_TYPE);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_TYPE);
 
         /* Initialize 1.5V regulator */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_DEV_GRP);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_DEV_GRP);
 
         twl->usb1v5 = regulator_get(twl->dev, "usb1v5");
         if (IS_ERR(twl->usb1v5))
                 goto fail1;
 
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_TYPE);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_TYPE);
 
         /* Initialize 1.8V regulator */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_DEV_GRP);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_DEV_GRP);
 
         twl->usb1v8 = regulator_get(twl->dev, "usb1v8");
         if (IS_ERR(twl->usb1v8))
                 goto fail2;
 
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_TYPE);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_TYPE);
 
         /* disable access to power configuration registers */
-        twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, PROTECT_KEY);
+        twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, PROTECT_KEY);
 
         return 0;
 
@@ -564,7 +556,7 @@ static ssize_t twl4030_usb_vbus_show(struct device *dev,
 
         spin_lock_irqsave(&twl->lock, flags);
         ret = sprintf(buf, "%s\n",
-                        (twl->linkstat == USB_LINK_VBUS) ? "on" : "off");
+                        (twl->linkstat == USB_EVENT_VBUS) ? "on" : "off");
         spin_unlock_irqrestore(&twl->lock, flags);
 
         return ret;
@@ -576,17 +568,8 @@ static irqreturn_t twl4030_usb_irq(int irq, void *_twl)
         struct twl4030_usb *twl = _twl;
         int status;
 
-#ifdef CONFIG_LOCKDEP
-        /* WORKAROUND for lockdep forcing IRQF_DISABLED on us, which
-         * we don't want and can't tolerate.  Although it might be
-         * friendlier not to borrow this thread context...
-         */
-        local_irq_enable();
-#endif
-
         status = twl4030_usb_linkstat(twl);
-        if (status != USB_LINK_UNKNOWN) {
-
+        if (status >= 0) {
                 /* FIXME add a set_power() method so that B-devices can
                  * configure the charger appropriately.  It's not always
                  * correct to consume VBUS power, and how much current to
@@ -598,12 +581,13 @@ static irqreturn_t twl4030_usb_irq(int irq, void *_twl)
                  * USB_LINK_VBUS state.  musb_hdrc won't care until it
                  * starts to handle softconnect right.
                  */
-                twl4030charger_usb_en(status == USB_LINK_VBUS);
-
-                if (status == USB_LINK_NONE)
+                if (status == USB_EVENT_NONE)
                         twl4030_phy_suspend(twl, 0);
                 else
                         twl4030_phy_resume(twl);
+
+                blocking_notifier_call_chain(&twl->otg.notifier, status,
+                                twl->otg.gadget);
         }
         sysfs_notify(&twl->dev->kobj, NULL, "vbus");
 
@@ -693,6 +677,8 @@ static int __devinit twl4030_usb_probe(struct platform_device *pdev)
         if (device_create_file(&pdev->dev, &dev_attr_vbus))
                 dev_warn(&pdev->dev, "could not create sysfs file\n");
 
+        BLOCKING_INIT_NOTIFIER_HEAD(&twl->otg.notifier);
+
         /* Our job is to use irqs and status from the power module
          * to keep the transceiver disabled when nothing's connected.
          *
@@ -702,7 +688,7 @@ static int __devinit twl4030_usb_probe(struct platform_device *pdev)
          * need both handles, otherwise just one suffices.
          */
         twl->irq_enabled = true;
-        status = request_irq(twl->irq, twl4030_usb_irq,
+        status = request_threaded_irq(twl->irq, NULL, twl4030_usb_irq,
                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
                         "twl4030_usb", twl);
         if (status < 0) {
diff --git a/drivers/usb/otg/ulpi.c b/drivers/usb/otg/ulpi.c
new file mode 100644
index 000000000000..9010225e0d06
--- /dev/null
+++ b/drivers/usb/otg/ulpi.c
@@ -0,0 +1,137 @@
+/*
+ * Generic ULPI USB transceiver support
+ *
+ * Copyright (C) 2009 Daniel Mack <daniel@caiaq.de>
+ *
+ * Based on sources from
+ *
+ *   Sascha Hauer <s.hauer@pengutronix.de>
+ *   Freescale Semiconductors
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/usb/otg.h>
+#include <linux/usb/ulpi.h>
+
+/* ULPI register addresses */
+#define ULPI_VID_LOW         0x00    /* Vendor ID low */
+#define ULPI_VID_HIGH        0x01    /* Vendor ID high */
+#define ULPI_PID_LOW         0x02    /* Product ID low */
+#define ULPI_PID_HIGH        0x03    /* Product ID high */
+#define ULPI_ITFCTL          0x07    /* Interface Control */
+#define ULPI_OTGCTL          0x0A    /* OTG Control */
+
+/* add to above register address to access Set/Clear functions */
+#define ULPI_REG_SET         0x01
+#define ULPI_REG_CLEAR       0x02
+
+/* ULPI OTG Control Register bits */
+#define ID_PULL_UP              (1 << 0)        /* enable ID Pull Up */
+#define DP_PULL_DOWN            (1 << 1)        /* enable DP Pull Down */
+#define DM_PULL_DOWN            (1 << 2)        /* enable DM Pull Down */
+#define DISCHRG_VBUS            (1 << 3)        /* Discharge Vbus */
+#define CHRG_VBUS               (1 << 4)        /* Charge Vbus */
+#define DRV_VBUS                (1 << 5)        /* Drive Vbus */
+#define DRV_VBUS_EXT            (1 << 6)        /* Drive Vbus external */
+#define USE_EXT_VBUS_IND        (1 << 7)        /* Use ext. Vbus indicator */
+
+#define ULPI_ID(vendor, product) (((vendor) << 16) | (product))
+
+#define TR_FLAG(flags, a, b)    (((flags) & a) ? b : 0)
+
+/* ULPI hardcoded IDs, used for probing */
+static unsigned int ulpi_ids[] = {
+        ULPI_ID(0x04cc, 0x1504),        /* NXP ISP1504 */
+};
+
+static int ulpi_set_flags(struct otg_transceiver *otg)
+{
+        unsigned int flags = 0;
+
+        if (otg->flags & USB_OTG_PULLUP_ID)
+                flags |= ID_PULL_UP;
+
+        if (otg->flags & USB_OTG_PULLDOWN_DM)
+                flags |= DM_PULL_DOWN;
+
+        if (otg->flags & USB_OTG_PULLDOWN_DP)
+                flags |= DP_PULL_DOWN;
+
+        if (otg->flags & USB_OTG_EXT_VBUS_INDICATOR)
+                flags |= USE_EXT_VBUS_IND;
+
+        return otg_io_write(otg, flags, ULPI_OTGCTL + ULPI_REG_SET);
+}
+
+static int ulpi_init(struct otg_transceiver *otg)
+{
+        int i, vid, pid;
+
+        vid = (otg_io_read(otg, ULPI_VID_HIGH) << 8) |
+               otg_io_read(otg, ULPI_VID_LOW);
+        pid = (otg_io_read(otg, ULPI_PID_HIGH) << 8) |
+               otg_io_read(otg, ULPI_PID_LOW);
+
+        pr_info("ULPI transceiver vendor/product ID 0x%04x/0x%04x\n", vid, pid);
+
+        for (i = 0; i < ARRAY_SIZE(ulpi_ids); i++)
+                if (ulpi_ids[i] == ULPI_ID(vid, pid))
+                        return ulpi_set_flags(otg);
+
+        pr_err("ULPI ID does not match any known transceiver.\n");
+        return -ENODEV;
+}
+
+static int ulpi_set_vbus(struct otg_transceiver *otg, bool on)
+{
+        unsigned int flags = otg_io_read(otg, ULPI_OTGCTL);
+
+        flags &= ~(DRV_VBUS | DRV_VBUS_EXT);
+
+        if (on) {
+                if (otg->flags & USB_OTG_DRV_VBUS)
+                        flags |= DRV_VBUS;
+
+                if (otg->flags & USB_OTG_DRV_VBUS_EXT)
+                        flags |= DRV_VBUS_EXT;
+        }
+
+        return otg_io_write(otg, flags, ULPI_OTGCTL + ULPI_REG_SET);
+}
+
+struct otg_transceiver *
+otg_ulpi_create(struct otg_io_access_ops *ops,
+                unsigned int flags)
+{
+        struct otg_transceiver *otg;
+
+        otg = kzalloc(sizeof(*otg), GFP_KERNEL);
+        if (!otg)
+                return NULL;
+
+        otg->label      = "ULPI";
+        otg->flags      = flags;
+        otg->io_ops     = ops;
+        otg->init       = ulpi_init;
+        otg->set_vbus   = ulpi_set_vbus;
+
+        return otg;
+}
+EXPORT_SYMBOL_GPL(otg_ulpi_create);
+
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index c480ea4c19f2..a0ecb42cb33a 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -472,6 +472,17 @@ config USB_SERIAL_OTI6858
           To compile this driver as a module, choose M here: the
           module will be called oti6858.
 
+config USB_SERIAL_QCAUX
+        tristate "USB Qualcomm Auxiliary Serial Port Driver"
+        help
+          Say Y here if you want to use the auxiliary serial ports provided
+          by many modems based on Qualcomm chipsets.  These ports often use
+          a proprietary protocol called DM and cannot be used for AT- or
+          PPP-based communication.
+
+          To compile this driver as a module, choose M here: the
+          module will be called qcaux.  If unsure, choose N.
+
 config USB_SERIAL_QUALCOMM
         tristate "USB Qualcomm Serial modem"
         help
@@ -600,6 +611,14 @@ config USB_SERIAL_OPTICON
           To compile this driver as a module, choose M here: the
           module will be called opticon.
 
+config USB_SERIAL_VIVOPAY_SERIAL
+        tristate "USB ViVOpay serial interface driver"
+        help
+          Say Y here if you want to use a ViVOtech ViVOpay USB device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called vivopay-serial.
+
 config USB_SERIAL_DEBUG
         tristate "USB Debugging Device"
         help
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 66619beb6cc0..83c9e431a568 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -45,6 +45,7 @@ obj-$(CONFIG_USB_SERIAL_OPTICON)		+= opticon.o
 obj-$(CONFIG_USB_SERIAL_OPTION)                 += option.o
 obj-$(CONFIG_USB_SERIAL_OTI6858)                += oti6858.o
 obj-$(CONFIG_USB_SERIAL_PL2303)                 += pl2303.o
+obj-$(CONFIG_USB_SERIAL_QCAUX)                  += qcaux.o
 obj-$(CONFIG_USB_SERIAL_QUALCOMM)               += qcserial.o
 obj-$(CONFIG_USB_SERIAL_SAFE)                   += safe_serial.o
 obj-$(CONFIG_USB_SERIAL_SIEMENS_MPI)            += siemens_mpi.o
@@ -55,4 +56,5 @@ obj-$(CONFIG_USB_SERIAL_TI)			+= ti_usb_3410_5052.o
 obj-$(CONFIG_USB_SERIAL_VISOR)                  += visor.o
 obj-$(CONFIG_USB_SERIAL_WHITEHEAT)              += whiteheat.o
 obj-$(CONFIG_USB_SERIAL_XIRCOM)                 += keyspan_pda.o
+obj-$(CONFIG_USB_SERIAL_VIVOPAY_SERIAL) += vivopay-serial.o
 
diff --git a/drivers/usb/serial/aircable.c b/drivers/usb/serial/aircable.c
index b10ac8409411..4fd7af98b1ae 100644
--- a/drivers/usb/serial/aircable.c
+++ b/drivers/usb/serial/aircable.c
@@ -43,6 +43,7 @@
  */
 
 #include <linux/tty.h>
+#include <linux/slab.h>
 #include <linux/tty_flip.h>
 #include <linux/circ_buf.h>
 #include <linux/usb.h>
@@ -78,7 +79,7 @@ static int debug;
 #define DRIVER_DESC "AIRcable USB Driver"
 
 /* ID table that will be registered with USB core */
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(AIRCABLE_VID, AIRCABLE_USB_PID) },
         { },
 };
@@ -468,10 +469,6 @@ static void aircable_read_bulk_callback(struct urb *urb)
 
         if (status) {
                 dbg("%s - urb status = %d", __func__, status);
-                if (!port->port.count) {
-                        dbg("%s - port is closed, exiting.", __func__);
-                        return;
-                }
                 if (status == -EPROTO) {
                         dbg("%s - caught -EPROTO, resubmitting the urb",
                             __func__);
@@ -530,23 +527,19 @@ static void aircable_read_bulk_callback(struct urb *urb)
         }
         tty_kref_put(tty);
 
-        /* Schedule the next read _if_ we are still open */
-        if (port->port.count) {
-                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);
-
-                result = usb_submit_urb(urb, GFP_ATOMIC);
-                if (result)
-                        dev_err(&urb->dev->dev,
-                                "%s - failed resubmitting read urb, error %d\n",
-                                __func__, result);
-        }
-
-        return;
+        /* Schedule the next read */
+        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);
+
+        result = usb_submit_urb(urb, GFP_ATOMIC);
+        if (result && result != -EPERM)
+                dev_err(&urb->dev->dev,
+                        "%s - failed resubmitting read urb, error %d\n",
+                        __func__, result);
 }
 
 /* Based on ftdi_sio.c throttle */
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index 131e61adaaf7..9b66bf19f751 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -1,4 +1,6 @@
 /*
+ * Copyright (C) 2009 by Bart Hartgers (bart.hartgers+ark3116@gmail.com)
+ * Original version:
  * Copyright (C) 2006
  *   Simon Schulz (ark3116_driver <at> auctionant.de)
  *
@@ -6,10 +8,13 @@
  * - implements a driver for the arkmicro ark3116 chipset (vendor=0x6547,
  *   productid=0x0232) (used in a datacable called KQ-U8A)
  *
- * - based on code by krisfx -> thanks !!
- *   (see http://www.linuxquestions.org/questions/showthread.php?p=2184457#post2184457)
+ * Supports full modem status lines, break, hardware flow control. Does not
+ * support software flow control, since I do not know how to enable it in hw.
  *
- *  - based on logs created by usbsnoopy
+ * This driver is a essentially new implementation. I initially dug
+ * into the old ark3116.c driver and suddenly realized the ark3116 is
+ * a 16450 with a USB interface glued to it. See comments at the
+ * bottom of this file.
  *
  * 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
@@ -19,17 +24,34 @@
 
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/ioctl.h>
 #include <linux/tty.h>
+#include <linux/slab.h>
+#include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include <linux/serial.h>
+#include <linux/serial_reg.h>
 #include <linux/uaccess.h>
-
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
 
 static int debug;
+/*
+ * Version information
+ */
 
-static struct usb_device_id id_table [] = {
+#define DRIVER_VERSION "v0.5"
+#define DRIVER_AUTHOR "Bart Hartgers <bart.hartgers+ark3116@gmail.com>"
+#define DRIVER_DESC "USB ARK3116 serial/IrDA driver"
+#define DRIVER_DEV_DESC "ARK3116 RS232/IrDA"
+#define DRIVER_NAME "ark3116"
+
+/* usb timeout of 1 second */
+#define ARK_TIMEOUT (1*HZ)
+
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x6547, 0x0232) },
         { USB_DEVICE(0x18ec, 0x3118) },         /* USB to IrDA adapter */
         { },
@@ -45,118 +67,152 @@ static int is_irda(struct usb_serial *serial)
         return 0;
 }
 
-static inline void ARK3116_SND(struct usb_serial *serial, int seq,
-                               __u8 request, __u8 requesttype,
-                               __u16 value, __u16 index)
+struct ark3116_private {
+        wait_queue_head_t       delta_msr_wait;
+        struct async_icount     icount;
+        int                     irda;   /* 1 for irda device */
+
+        /* protects hw register updates */
+        struct mutex            hw_lock;
+
+        int                     quot;   /* baudrate divisor */
+        __u32                   lcr;    /* line control register value */
+        __u32                   hcr;    /* handshake control register (0x8)
+                                         * value */
+        __u32                   mcr;    /* modem contol register value */
+
+        /* protects the status values below */
+        spinlock_t              status_lock;
+        __u32                   msr;    /* modem status register value */
+        __u32                   lsr;    /* line status register value */
+};
+
+static int ark3116_write_reg(struct usb_serial *serial,
+                             unsigned reg, __u8 val)
 {
         int result;
+         /* 0xfe 0x40 are magic values taken from original driver */
         result = usb_control_msg(serial->dev,
                                  usb_sndctrlpipe(serial->dev, 0),
-                                 request, requesttype, value, index,
-                                 NULL, 0x00, 1000);
-        dbg("%03d > ok", seq);
+                                 0xfe, 0x40, val, reg,
+                                 NULL, 0, ARK_TIMEOUT);
+        return result;
 }
 
-static inline void ARK3116_RCV(struct usb_serial *serial, int seq,
-                               __u8 request, __u8 requesttype,
-                               __u16 value, __u16 index, __u8 expected,
-                               char *buf)
+static int ark3116_read_reg(struct usb_serial *serial,
+                            unsigned reg, unsigned char *buf)
 {
         int result;
+        /* 0xfe 0xc0 are magic values taken from original driver */
         result = usb_control_msg(serial->dev,
                                  usb_rcvctrlpipe(serial->dev, 0),
-                                 request, requesttype, value, index,
-                                 buf, 0x0000001, 1000);
-        if (result)
-                dbg("%03d < %d bytes [0x%02X]", seq, result,
-                    ((unsigned char *)buf)[0]);
+                                 0xfe, 0xc0, 0, reg,
+                                 buf, 1, ARK_TIMEOUT);
+        if (result < 0)
+                return result;
         else
-                dbg("%03d < 0 bytes", seq);
+                return buf[0];
 }
 
-static inline void ARK3116_RCV_QUIET(struct usb_serial *serial,
-                                     __u8 request, __u8 requesttype,
-                                     __u16 value, __u16 index, char *buf)
+static inline int calc_divisor(int bps)
 {
-        usb_control_msg(serial->dev,
-                        usb_rcvctrlpipe(serial->dev, 0),
-                        request, requesttype, value, index,
-                        buf, 0x0000001, 1000);
+        /* Original ark3116 made some exceptions in rounding here
+         * because windows did the same. Assume that is not really
+         * necessary.
+         * Crystal is 12MHz, probably because of USB, but we divide by 4?
+         */
+        return (12000000 + 2*bps) / (4*bps);
 }
 
 static int ark3116_attach(struct usb_serial *serial)
 {
-        char *buf;
+        struct usb_serial_port *port = serial->port[0];
+        struct ark3116_private *priv;
+
+        /* make sure we have our end-points */
+        if ((serial->num_bulk_in == 0) ||
+            (serial->num_bulk_out == 0) ||
+            (serial->num_interrupt_in == 0)) {
+                dev_err(&serial->dev->dev,
+                        "%s - missing endpoint - "
+                        "bulk in: %d, bulk out: %d, int in %d\n",
+                        KBUILD_MODNAME,
+                        serial->num_bulk_in,
+                        serial->num_bulk_out,
+                        serial->num_interrupt_in);
+                return -EINVAL;
+        }
 
-        buf = kmalloc(1, GFP_KERNEL);
-        if (!buf) {
-                dbg("error kmalloc -> out of mem?");
+        priv = kzalloc(sizeof(struct ark3116_private),
+                       GFP_KERNEL);
+        if (!priv)
                 return -ENOMEM;
-        }
 
-        if (is_irda(serial))
-                dbg("IrDA mode");
+        init_waitqueue_head(&priv->delta_msr_wait);
+        mutex_init(&priv->hw_lock);
+        spin_lock_init(&priv->status_lock);
+
+        priv->irda = is_irda(serial);
 
-        /* 3 */
-        ARK3116_SND(serial, 3, 0xFE, 0x40, 0x0008, 0x0002);
-        ARK3116_SND(serial, 4, 0xFE, 0x40, 0x0008, 0x0001);
-        ARK3116_SND(serial, 5, 0xFE, 0x40, 0x0000, 0x0008);
-        ARK3116_SND(serial, 6, 0xFE, 0x40, is_irda(serial) ? 0x0001 : 0x0000,
-                    0x000B);
+        usb_set_serial_port_data(port, priv);
 
-        if (is_irda(serial)) {
-                ARK3116_SND(serial, 1001, 0xFE, 0x40, 0x0000, 0x000C);
-                ARK3116_SND(serial, 1002, 0xFE, 0x40, 0x0041, 0x000D);
-                ARK3116_SND(serial, 1003, 0xFE, 0x40, 0x0001, 0x000A);
+        /* setup the hardware */
+        ark3116_write_reg(serial, UART_IER, 0);
+        /* disable DMA */
+        ark3116_write_reg(serial, UART_FCR, 0);
+        /* handshake control */
+        priv->hcr = 0;
+        ark3116_write_reg(serial, 0x8     , 0);
+        /* modem control */
+        priv->mcr = 0;
+        ark3116_write_reg(serial, UART_MCR, 0);
+
+        if (!(priv->irda)) {
+                ark3116_write_reg(serial, 0xb , 0);
+        } else {
+                ark3116_write_reg(serial, 0xb , 1);
+                ark3116_write_reg(serial, 0xc , 0);
+                ark3116_write_reg(serial, 0xd , 0x41);
+                ark3116_write_reg(serial, 0xa , 1);
         }
 
-        /* <-- seq7 */
-        ARK3116_RCV(serial,  7, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
-        ARK3116_SND(serial,  8, 0xFE, 0x40, 0x0080, 0x0003);
-        ARK3116_SND(serial,  9, 0xFE, 0x40, 0x001A, 0x0000);
-        ARK3116_SND(serial, 10, 0xFE, 0x40, 0x0000, 0x0001);
-        ARK3116_SND(serial, 11, 0xFE, 0x40, 0x0000, 0x0003);
-
-        /* <-- seq12 */
-        ARK3116_RCV(serial, 12, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
-        ARK3116_SND(serial, 13, 0xFE, 0x40, 0x0000, 0x0004);
-
-        /* 14 */
-        ARK3116_RCV(serial, 14, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
-        ARK3116_SND(serial, 15, 0xFE, 0x40, 0x0000, 0x0004);
-
-        /* 16 */
-        ARK3116_RCV(serial, 16, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
-        /* --> seq17 */
-        ARK3116_SND(serial, 17, 0xFE, 0x40, 0x0001, 0x0004);
-
-        /* <-- seq18 */
-        ARK3116_RCV(serial, 18, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
-
-        /* --> seq19 */
-        ARK3116_SND(serial, 19, 0xFE, 0x40, 0x0003, 0x0004);
-
-        /* <-- seq20 */
-        /* seems like serial port status info (RTS, CTS, ...) */
-        /* returns modem control line status?! */
-        ARK3116_RCV(serial, 20, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);
-
-        /* set 9600 baud & do some init?! */
-        ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
-        ARK3116_SND(serial, 148, 0xFE, 0x40, 0x0038, 0x0000);
-        ARK3116_SND(serial, 149, 0xFE, 0x40, 0x0001, 0x0001);
-        if (is_irda(serial))
-                ARK3116_SND(serial, 1004, 0xFE, 0x40, 0x0000, 0x0009);
-        ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
-        ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
-        ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
-        ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
-        ARK3116_SND(serial, 154, 0xFE, 0x40, 0x0003, 0x0003);
+        /* setup baudrate */
+        ark3116_write_reg(serial, UART_LCR, UART_LCR_DLAB);
 
-        kfree(buf);
+        /* setup for 9600 8N1 */
+        priv->quot = calc_divisor(9600);
+        ark3116_write_reg(serial, UART_DLL, priv->quot & 0xff);
+        ark3116_write_reg(serial, UART_DLM, (priv->quot>>8) & 0xff);
+
+        priv->lcr = UART_LCR_WLEN8;
+        ark3116_write_reg(serial, UART_LCR, UART_LCR_WLEN8);
+
+        ark3116_write_reg(serial, 0xe, 0);
+
+        if (priv->irda)
+                ark3116_write_reg(serial, 0x9, 0);
+
+        dev_info(&serial->dev->dev,
+                "%s using %s mode\n",
+                KBUILD_MODNAME,
+                priv->irda ? "IrDA" : "RS232");
         return 0;
 }
 
+static void ark3116_release(struct usb_serial *serial)
+{
+        struct usb_serial_port *port = serial->port[0];
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
+
+        /* device is closed, so URBs and DMA should be down */
+
+        usb_set_serial_port_data(port, NULL);
+
+        mutex_destroy(&priv->hw_lock);
+
+        kfree(priv);
+}
+
 static void ark3116_init_termios(struct tty_struct *tty)
 {
         struct ktermios *termios = tty->termios;
@@ -172,200 +228,189 @@ static void ark3116_set_termios(struct tty_struct *tty,
                                 struct ktermios *old_termios)
 {
         struct usb_serial *serial = port->serial;
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
         struct ktermios *termios = tty->termios;
         unsigned int cflag = termios->c_cflag;
-        int baud;
-        int ark3116_baud;
-        char *buf;
-        char config;
-
-        config = 0;
-
-        dbg("%s - port %d", __func__, port->number);
+        int bps = tty_get_baud_rate(tty);
+        int quot;
+        __u8 lcr, hcr, eval;
+
+        /* set data bit count */
+        switch (cflag & CSIZE) {
+        case CS5:
+                lcr = UART_LCR_WLEN5;
+                break;
+        case CS6:
+                lcr = UART_LCR_WLEN6;
+                break;
+        case CS7:
+                lcr = UART_LCR_WLEN7;
+                break;
+        default:
+        case CS8:
+                lcr = UART_LCR_WLEN8;
+                break;
+        }
+        if (cflag & CSTOPB)
+                lcr |= UART_LCR_STOP;
+        if (cflag & PARENB)
+                lcr |= UART_LCR_PARITY;
+        if (!(cflag & PARODD))
+                lcr |= UART_LCR_EPAR;
+#ifdef CMSPAR
+        if (cflag & CMSPAR)
+                lcr |= UART_LCR_SPAR;
+#endif
+        /* handshake control */
+        hcr = (cflag & CRTSCTS) ? 0x03 : 0x00;
+
+        /* calc baudrate */
+        dbg("%s - setting bps to %d", __func__, bps);
+        eval = 0;
+        switch (bps) {
+        case 0:
+                quot = calc_divisor(9600);
+                break;
+        default:
+                if ((bps < 75) || (bps > 3000000))
+                        bps = 9600;
+                quot = calc_divisor(bps);
+                break;
+        case 460800:
+                eval = 1;
+                quot = calc_divisor(bps);
+                break;
+        case 921600:
+                eval = 2;
+                quot = calc_divisor(bps);
+                break;
+        }
 
+        /* Update state: synchronize */
+        mutex_lock(&priv->hw_lock);
 
-        cflag = termios->c_cflag;
-        termios->c_cflag &= ~(CMSPAR|CRTSCTS);
+        /* keep old LCR_SBC bit */
+        lcr |= (priv->lcr & UART_LCR_SBC);
 
-        buf = kmalloc(1, GFP_KERNEL);
-        if (!buf) {
-                dbg("error kmalloc");
-                *termios = *old_termios;
-                return;
-        }
+        dbg("%s - setting hcr:0x%02x,lcr:0x%02x,quot:%d",
+            __func__, hcr, lcr, quot);
 
-        /* set data bit count (8/7/6/5) */
-        if (cflag & CSIZE) {
-                switch (cflag & CSIZE) {
-                case CS5:
-                        config |= 0x00;
-                        dbg("setting CS5");
-                        break;
-                case CS6:
-                        config |= 0x01;
-                        dbg("setting CS6");
-                        break;
-                case CS7:
-                        config |= 0x02;
-                        dbg("setting CS7");
-                        break;
-                default:
-                        dbg("CSIZE was set but not CS5-CS8, using CS8!");
-                        /* fall through */
-                case CS8:
-                        config |= 0x03;
-                        dbg("setting CS8");
-                        break;
-                }
+        /* handshake control */
+        if (priv->hcr != hcr) {
+                priv->hcr = hcr;
+                ark3116_write_reg(serial, 0x8, hcr);
         }
 
-        /* set parity (NONE/EVEN/ODD) */
-        if (cflag & PARENB) {
-                if (cflag & PARODD) {
-                        config |= 0x08;
-                        dbg("setting parity to ODD");
-                } else {
-                        config |= 0x18;
-                        dbg("setting parity to EVEN");
-                }
-        } else {
-                dbg("setting parity to NONE");
+        /* baudrate */
+        if (priv->quot != quot) {
+                priv->quot = quot;
+                priv->lcr = lcr; /* need to write lcr anyway */
+
+                /* disable DMA since transmit/receive is
+                 * shadowed by UART_DLL
+                 */
+                ark3116_write_reg(serial, UART_FCR, 0);
+
+                ark3116_write_reg(serial, UART_LCR,
+                                  lcr|UART_LCR_DLAB);
+                ark3116_write_reg(serial, UART_DLL, quot & 0xff);
+                ark3116_write_reg(serial, UART_DLM, (quot>>8) & 0xff);
+
+                /* restore lcr */
+                ark3116_write_reg(serial, UART_LCR, lcr);
+                /* magic baudrate thingy: not sure what it does,
+                 * but windows does this as well.
+                 */
+                ark3116_write_reg(serial, 0xe, eval);
+
+                /* enable DMA */
+                ark3116_write_reg(serial, UART_FCR, UART_FCR_DMA_SELECT);
+        } else if (priv->lcr != lcr) {
+                priv->lcr = lcr;
+                ark3116_write_reg(serial, UART_LCR, lcr);
         }
 
-        /* set stop bit (1/2) */
-        if (cflag & CSTOPB) {
-                config |= 0x04;
-                dbg("setting 2 stop bits");
-        } else {
-                dbg("setting 1 stop bit");
-        }
+        mutex_unlock(&priv->hw_lock);
 
-        /* set baudrate */
-        baud = tty_get_baud_rate(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(tty, baud, baud);
-                break;
-        /* set 9600 as default (if given baudrate is invalid for example) */
-        default:
-                tty_encode_baud_rate(tty, 9600, 9600);
-        case 0:
-                baud = 9600;
+        /* check for software flow control */
+        if (I_IXOFF(tty) || I_IXON(tty)) {
+                dev_warn(&serial->dev->dev,
+                         "%s: don't know how to do software flow control\n",
+                         KBUILD_MODNAME);
         }
 
-        /*
-         * found by try'n'error, be careful, maybe there are other options
-         * for multiplicator etc! (3.5 for example)
-         */
-        if (baud == 460800)
-                /* strange, for 460800 the formula is wrong
-                 * if using round() then 9600baud is wrong) */
-                ark3116_baud = 7;
-        else
-                ark3116_baud = 3000000 / baud;
-
-        /* ? */
-        ARK3116_RCV(serial, 0, 0xFE, 0xC0, 0x0000, 0x0003, 0x03, buf);
-
-        /* offset = buf[0]; */
-        /* offset = 0x03; */
-        /* dbg("using 0x%04X as target for 0x0003:", 0x0080 + offset); */
-
-        /* set baudrate */
-        dbg("setting baudrate to %d (->reg=%d)", baud, ark3116_baud);
-        ARK3116_SND(serial, 147, 0xFE, 0x40, 0x0083, 0x0003);
-        ARK3116_SND(serial, 148, 0xFE, 0x40,
-                            (ark3116_baud & 0x00FF), 0x0000);
-        ARK3116_SND(serial, 149, 0xFE, 0x40,
-                            (ark3116_baud & 0xFF00) >> 8, 0x0001);
-        ARK3116_SND(serial, 150, 0xFE, 0x40, 0x0003, 0x0003);
-
-        /* ? */
-        ARK3116_RCV(serial, 151, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
-        ARK3116_SND(serial, 152, 0xFE, 0x40, 0x0000, 0x0003);
-
-        /* set data bit count, stop bit count & parity: */
-        dbg("updating bit count, stop bit or parity (cfg=0x%02X)", config);
-        ARK3116_RCV(serial, 153, 0xFE, 0xC0, 0x0000, 0x0003, 0x00, buf);
-        ARK3116_SND(serial, 154, 0xFE, 0x40, config, 0x0003);
+        /* Don't rewrite B0 */
+        if (tty_termios_baud_rate(termios))
+                tty_termios_encode_baud_rate(termios, bps, bps);
+}
 
-        if (cflag & CRTSCTS)
-                dbg("CRTSCTS not supported by chipset?!");
+static void ark3116_close(struct usb_serial_port *port)
+{
+        struct usb_serial *serial = port->serial;
 
-        /* TEST ARK3116_SND(154, 0xFE, 0x40, 0xFFFF, 0x0006); */
+        if (serial->dev) {
+                /* disable DMA */
+                ark3116_write_reg(serial, UART_FCR, 0);
 
-        kfree(buf);
+                /* deactivate interrupts */
+                ark3116_write_reg(serial, UART_IER, 0);
 
-        return;
+                /* shutdown any bulk reads that might be going on */
+                if (serial->num_bulk_out)
+                        usb_kill_urb(port->write_urb);
+                if (serial->num_bulk_in)
+                        usb_kill_urb(port->read_urb);
+                if (serial->num_interrupt_in)
+                        usb_kill_urb(port->interrupt_in_urb);
+        }
 }
 
 static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
-        struct ktermios tmp_termios;
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
         struct usb_serial *serial = port->serial;
-        char *buf;
-        int result = 0;
-
-        dbg("%s - port %d", __func__, port->number);
+        unsigned char *buf;
+        int result;
 
         buf = kmalloc(1, GFP_KERNEL);
-        if (!buf) {
-                dbg("error kmalloc -> out of mem?");
+        if (buf == NULL)
                 return -ENOMEM;
-        }
 
         result = usb_serial_generic_open(tty, port);
-        if (result)
+        if (result) {
+                dbg("%s - usb_serial_generic_open failed: %d",
+                    __func__, result);
                 goto err_out;
+        }
 
-        /* open */
-        ARK3116_RCV(serial, 111, 0xFE, 0xC0, 0x0000, 0x0003, 0x02, buf);
-
-        ARK3116_SND(serial, 112, 0xFE, 0x40, 0x0082, 0x0003);
-        ARK3116_SND(serial, 113, 0xFE, 0x40, 0x001A, 0x0000);
-        ARK3116_SND(serial, 114, 0xFE, 0x40, 0x0000, 0x0001);
-        ARK3116_SND(serial, 115, 0xFE, 0x40, 0x0002, 0x0003);
-
-        ARK3116_RCV(serial, 116, 0xFE, 0xC0, 0x0000, 0x0004, 0x03, buf);
-        ARK3116_SND(serial, 117, 0xFE, 0x40, 0x0002, 0x0004);
-
-        ARK3116_RCV(serial, 118, 0xFE, 0xC0, 0x0000, 0x0004, 0x02, buf);
-        ARK3116_SND(serial, 119, 0xFE, 0x40, 0x0000, 0x0004);
-
-        ARK3116_RCV(serial, 120, 0xFE, 0xC0, 0x0000, 0x0004, 0x00, buf);
+        /* setup termios */
+        if (tty)
+                ark3116_set_termios(tty, port, NULL);
 
-        ARK3116_SND(serial, 121, 0xFE, 0x40, 0x0001, 0x0004);
+        /* remove any data still left: also clears error state */
+        ark3116_read_reg(serial, UART_RX, buf);
 
-        ARK3116_RCV(serial, 122, 0xFE, 0xC0, 0x0000, 0x0004, 0x01, buf);
+        /* read modem status */
+        priv->msr = ark3116_read_reg(serial, UART_MSR, buf);
+        /* read line status */
+        priv->lsr = ark3116_read_reg(serial, UART_LSR, buf);
 
-        ARK3116_SND(serial, 123, 0xFE, 0x40, 0x0003, 0x0004);
+        result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
+        if (result) {
+                dev_err(&port->dev, "submit irq_in urb failed %d\n",
+                        result);
+                ark3116_close(port);
+                goto err_out;
+        }
 
-        /* returns different values (control lines?!) */
-        ARK3116_RCV(serial, 124, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);
+        /* activate interrupts */
+        ark3116_write_reg(port->serial, UART_IER, UART_IER_MSI|UART_IER_RLSI);
 
-        /* initialise termios */
-        if (tty)
-                ark3116_set_termios(tty, port, &tmp_termios);
+        /* enable DMA */
+        ark3116_write_reg(port->serial, UART_FCR, UART_FCR_DMA_SELECT);
 
 err_out:
         kfree(buf);
-
         return result;
 }
 
@@ -373,6 +418,7 @@ static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
                          unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
         struct serial_struct serstruct;
         void __user *user_arg = (void __user *)arg;
 
@@ -394,9 +440,48 @@ static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
                 if (copy_from_user(&serstruct, user_arg, sizeof(serstruct)))
                         return -EFAULT;
                 return 0;
-        default:
-                dbg("%s cmd 0x%04x not supported", __func__, cmd);
+        case TIOCMIWAIT:
+                for (;;) {
+                        struct async_icount prev = priv->icount;
+                        interruptible_sleep_on(&priv->delta_msr_wait);
+                        /* see if a signal did it */
+                        if (signal_pending(current))
+                                return -ERESTARTSYS;
+                        if ((prev.rng == priv->icount.rng) &&
+                            (prev.dsr == priv->icount.dsr) &&
+                            (prev.dcd == priv->icount.dcd) &&
+                            (prev.cts == priv->icount.cts))
+                                return -EIO;
+                        if ((arg & TIOCM_RNG &&
+                             (prev.rng != priv->icount.rng)) ||
+                            (arg & TIOCM_DSR &&
+                             (prev.dsr != priv->icount.dsr)) ||
+                            (arg & TIOCM_CD  &&
+                             (prev.dcd != priv->icount.dcd)) ||
+                            (arg & TIOCM_CTS &&
+                             (prev.cts != priv->icount.cts)))
+                                return 0;
+                }
                 break;
+        case TIOCGICOUNT: {
+                struct serial_icounter_struct icount;
+                struct async_icount cnow = priv->icount;
+                memset(&icount, 0, sizeof(icount));
+                icount.cts = cnow.cts;
+                icount.dsr = cnow.dsr;
+                icount.rng = cnow.rng;
+                icount.dcd = cnow.dcd;
+                icount.rx = cnow.rx;
+                icount.tx = cnow.tx;
+                icount.frame = cnow.frame;
+                icount.overrun = cnow.overrun;
+                icount.parity = cnow.parity;
+                icount.brk = cnow.brk;
+                icount.buf_overrun = cnow.buf_overrun;
+                if (copy_to_user(user_arg, &icount, sizeof(icount)))
+                        return -EFAULT;
+                return 0;
+        }
         }
 
         return -ENOIOCTLCMD;
@@ -405,32 +490,272 @@ static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
 static int ark3116_tiocmget(struct tty_struct *tty, struct file *file)
 {
         struct usb_serial_port *port = tty->driver_data;
-        struct usb_serial *serial = port->serial;
-        char *buf;
-        char temp;
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
+        __u32 status;
+        __u32 ctrl;
+        unsigned long flags;
+
+        mutex_lock(&priv->hw_lock);
+        ctrl = priv->mcr;
+        mutex_unlock(&priv->hw_lock);
+
+        spin_lock_irqsave(&priv->status_lock, flags);
+        status = priv->msr;
+        spin_unlock_irqrestore(&priv->status_lock, flags);
+
+        return  (status & UART_MSR_DSR  ? TIOCM_DSR  : 0) |
+                (status & UART_MSR_CTS  ? TIOCM_CTS  : 0) |
+                (status & UART_MSR_RI   ? TIOCM_RI   : 0) |
+                (status & UART_MSR_DCD  ? TIOCM_CD   : 0) |
+                (ctrl   & UART_MCR_DTR  ? TIOCM_DTR  : 0) |
+                (ctrl   & UART_MCR_RTS  ? TIOCM_RTS  : 0) |
+                (ctrl   & UART_MCR_OUT1 ? TIOCM_OUT1 : 0) |
+                (ctrl   & UART_MCR_OUT2 ? TIOCM_OUT2 : 0);
+}
 
-        /* seems like serial port status info (RTS, CTS, ...) is stored
-         * in reg(?) 0x0006
-         * pcb connection point 11 = GND -> sets bit4 of response
-         * pcb connection point  7 = GND -> sets bit6 of response
+static int ark3116_tiocmset(struct tty_struct *tty, struct file *file,
+                        unsigned set, unsigned clr)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
+
+        /* we need to take the mutex here, to make sure that the value
+         * in priv->mcr is actually the one that is in the hardware
          */
 
-        buf = kmalloc(1, GFP_KERNEL);
-        if (!buf) {
-                dbg("error kmalloc");
-                return -ENOMEM;
+        mutex_lock(&priv->hw_lock);
+
+        if (set & TIOCM_RTS)
+                priv->mcr |= UART_MCR_RTS;
+        if (set & TIOCM_DTR)
+                priv->mcr |= UART_MCR_DTR;
+        if (set & TIOCM_OUT1)
+                priv->mcr |= UART_MCR_OUT1;
+        if (set & TIOCM_OUT2)
+                priv->mcr |= UART_MCR_OUT2;
+        if (clr & TIOCM_RTS)
+                priv->mcr &= ~UART_MCR_RTS;
+        if (clr & TIOCM_DTR)
+                priv->mcr &= ~UART_MCR_DTR;
+        if (clr & TIOCM_OUT1)
+                priv->mcr &= ~UART_MCR_OUT1;
+        if (clr & TIOCM_OUT2)
+                priv->mcr &= ~UART_MCR_OUT2;
+
+        ark3116_write_reg(port->serial, UART_MCR, priv->mcr);
+
+        mutex_unlock(&priv->hw_lock);
+
+        return 0;
+}
+
+static void ark3116_break_ctl(struct tty_struct *tty, int break_state)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
+
+        /* LCR is also used for other things: protect access */
+        mutex_lock(&priv->hw_lock);
+
+        if (break_state)
+                priv->lcr |= UART_LCR_SBC;
+        else
+                priv->lcr &= ~UART_LCR_SBC;
+
+        ark3116_write_reg(port->serial, UART_LCR, priv->lcr);
+
+        mutex_unlock(&priv->hw_lock);
+}
+
+static void ark3116_update_msr(struct usb_serial_port *port, __u8 msr)
+{
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->status_lock, flags);
+        priv->msr = msr;
+        spin_unlock_irqrestore(&priv->status_lock, flags);
+
+        if (msr & UART_MSR_ANY_DELTA) {
+                /* update input line counters */
+                if (msr & UART_MSR_DCTS)
+                        priv->icount.cts++;
+                if (msr & UART_MSR_DDSR)
+                        priv->icount.dsr++;
+                if (msr & UART_MSR_DDCD)
+                        priv->icount.dcd++;
+                if (msr & UART_MSR_TERI)
+                        priv->icount.rng++;
+                wake_up_interruptible(&priv->delta_msr_wait);
         }
+}
 
-        /* read register */
-        ARK3116_RCV_QUIET(serial, 0xFE, 0xC0, 0x0000, 0x0006, buf);
-        temp = buf[0];
-        kfree(buf);
+static void ark3116_update_lsr(struct usb_serial_port *port, __u8 lsr)
+{
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->status_lock, flags);
+        /* combine bits */
+        priv->lsr |= lsr;
+        spin_unlock_irqrestore(&priv->status_lock, flags);
+
+        if (lsr&UART_LSR_BRK_ERROR_BITS) {
+                if (lsr & UART_LSR_BI)
+                        priv->icount.brk++;
+                if (lsr & UART_LSR_FE)
+                        priv->icount.frame++;
+                if (lsr & UART_LSR_PE)
+                        priv->icount.parity++;
+                if (lsr & UART_LSR_OE)
+                        priv->icount.overrun++;
+        }
+}
 
-        /* i do not really know if bit4=CTS and bit6=DSR... just a
-         * quick guess!
-         */
-        return (temp & (1<<4) ? TIOCM_CTS : 0)
-               | (temp & (1<<6) ? TIOCM_DSR : 0);
+static void ark3116_read_int_callback(struct urb *urb)
+{
+        struct usb_serial_port *port = urb->context;
+        int status = urb->status;
+        const __u8 *data = urb->transfer_buffer;
+        int result;
+
+        switch (status) {
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d",
+                    __func__, status);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d",
+                    __func__, status);
+                break;
+        case 0: /* success */
+                /* discovered this by trail and error... */
+                if ((urb->actual_length == 4) && (data[0] == 0xe8)) {
+                        const __u8 id = data[1]&UART_IIR_ID;
+                        dbg("%s: iir=%02x", __func__, data[1]);
+                        if (id == UART_IIR_MSI) {
+                                dbg("%s: msr=%02x", __func__, data[3]);
+                                ark3116_update_msr(port, data[3]);
+                                break;
+                        } else if (id == UART_IIR_RLSI) {
+                                dbg("%s: lsr=%02x", __func__, data[2]);
+                                ark3116_update_lsr(port, data[2]);
+                                break;
+                        }
+                }
+                /*
+                 * Not sure what this data meant...
+                 */
+                usb_serial_debug_data(debug, &port->dev,
+                                      __func__,
+                                      urb->actual_length,
+                                      urb->transfer_buffer);
+                break;
+        }
+
+        result = usb_submit_urb(urb, GFP_ATOMIC);
+        if (result)
+                dev_err(&urb->dev->dev,
+                        "%s - Error %d submitting interrupt urb\n",
+                        __func__, result);
+}
+
+
+/* Data comes in via the bulk (data) URB, erors/interrupts via the int URB.
+ * This means that we cannot be sure which data byte has an associated error
+ * condition, so we report an error for all data in the next bulk read.
+ *
+ * Actually, there might even be a window between the bulk data leaving the
+ * ark and reading/resetting the lsr in the read_bulk_callback where an
+ * interrupt for the next data block could come in.
+ * Without somekind of ordering on the ark, we would have to report the
+ * error for the next block of data as well...
+ * For now, let's pretend this can't happen.
+ */
+
+static void send_to_tty(struct tty_struct *tty,
+                        const unsigned char *chars,
+                        size_t size, char flag)
+{
+        if (size == 0)
+                return;
+        if (flag == TTY_NORMAL) {
+                tty_insert_flip_string(tty, chars, size);
+        } else {
+                int i;
+                for (i = 0; i < size; ++i)
+                        tty_insert_flip_char(tty, chars[i], flag);
+        }
+}
+
+static void ark3116_read_bulk_callback(struct urb *urb)
+{
+        struct usb_serial_port *port =  urb->context;
+        struct ark3116_private *priv = usb_get_serial_port_data(port);
+        const __u8 *data = urb->transfer_buffer;
+        int status = urb->status;
+        struct tty_struct *tty;
+        unsigned long flags;
+        int result;
+        char flag;
+        __u32 lsr;
+
+        switch (status) {
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d",
+                    __func__, status);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d",
+                    __func__, status);
+                break;
+        case 0: /* success */
+
+                spin_lock_irqsave(&priv->status_lock, flags);
+                lsr = priv->lsr;
+                /* clear error bits */
+                priv->lsr &= ~UART_LSR_BRK_ERROR_BITS;
+                spin_unlock_irqrestore(&priv->status_lock, flags);
+
+                if (unlikely(lsr & UART_LSR_BI))
+                        flag = TTY_BREAK;
+                else if (unlikely(lsr & UART_LSR_PE))
+                        flag = TTY_PARITY;
+                else if (unlikely(lsr & UART_LSR_FE))
+                        flag = TTY_FRAME;
+                else
+                        flag = TTY_NORMAL;
+
+                tty = tty_port_tty_get(&port->port);
+                if (tty) {
+                        /* overrun is special, not associated with a char */
+                        if (unlikely(lsr & UART_LSR_OE))
+                                tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+                        send_to_tty(tty, data, urb->actual_length, flag);
+                        tty_flip_buffer_push(tty);
+                        tty_kref_put(tty);
+                }
+
+                /* Throttle the device if requested by tty */
+                spin_lock_irqsave(&port->lock, flags);
+                port->throttled = port->throttle_req;
+                if (port->throttled) {
+                        spin_unlock_irqrestore(&port->lock, flags);
+                        return;
+                } else
+                        spin_unlock_irqrestore(&port->lock, flags);
+        }
+        /* Continue reading from device */
+        result = usb_submit_urb(urb, GFP_ATOMIC);
+        if (result)
+                dev_err(&urb->dev->dev, "%s - failed resubmitting"
+                        " read urb, error %d\n", __func__, result);
 }
 
 static struct usb_driver ark3116_driver = {
@@ -450,11 +775,17 @@ static struct usb_serial_driver ark3116_device = {
         .usb_driver =           &ark3116_driver,
         .num_ports =            1,
         .attach =               ark3116_attach,
+        .release =              ark3116_release,
         .set_termios =          ark3116_set_termios,
         .init_termios =         ark3116_init_termios,
         .ioctl =                ark3116_ioctl,
         .tiocmget =             ark3116_tiocmget,
+        .tiocmset =             ark3116_tiocmset,
         .open =                 ark3116_open,
+        .close =                ark3116_close,
+        .break_ctl =            ark3116_break_ctl,
+        .read_int_callback =    ark3116_read_int_callback,
+        .read_bulk_callback =   ark3116_read_bulk_callback,
 };
 
 static int __init ark3116_init(void)
@@ -465,7 +796,12 @@ static int __init ark3116_init(void)
         if (retval)
                 return retval;
         retval = usb_register(&ark3116_driver);
-        if (retval)
+        if (retval == 0) {
+                printk(KERN_INFO "%s:"
+                       DRIVER_VERSION ":"
+                       DRIVER_DESC "\n",
+                       KBUILD_MODNAME);
+        } else
                 usb_serial_deregister(&ark3116_device);
         return retval;
 }
@@ -480,6 +816,109 @@ module_init(ark3116_init);
 module_exit(ark3116_exit);
 MODULE_LICENSE("GPL");
 
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+
 module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
+MODULE_PARM_DESC(debug, "Enable debug");
 
+/*
+ * The following describes what I learned from studying the old
+ * ark3116.c driver, disassembling the windows driver, and some lucky
+ * guesses. Since I do not have any datasheet or other
+ * documentation, inaccuracies are almost guaranteed.
+ *
+ * Some specs for the ARK3116 can be found here:
+ * http://web.archive.org/web/20060318000438/
+ *   www.arkmicro.com/en/products/view.php?id=10
+ * On that page, 2 GPIO pins are mentioned: I assume these are the
+ * OUT1 and OUT2 pins of the UART, so I added support for those
+ * through the MCR. Since the pins are not available on my hardware,
+ * I could not verify this.
+ * Also, it states there is "on-chip hardware flow control". I have
+ * discovered how to enable that. Unfortunately, I do not know how to
+ * enable XON/XOFF (software) flow control, which would need support
+ * from the chip as well to work. Because of the wording on the web
+ * page there is a real possibility the chip simply does not support
+ * software flow control.
+ *
+ * I got my ark3116 as part of a mobile phone adapter cable. On the
+ * PCB, the following numbered contacts are present:
+ *
+ *  1:- +5V
+ *  2:o DTR
+ *  3:i RX
+ *  4:i DCD
+ *  5:o RTS
+ *  6:o TX
+ *  7:i RI
+ *  8:i DSR
+ * 10:- 0V
+ * 11:i CTS
+ *
+ * On my chip, all signals seem to be 3.3V, but 5V tolerant. But that
+ * may be different for the one you have ;-).
+ *
+ * The windows driver limits the registers to 0-F, so I assume there
+ * are actually 16 present on the device.
+ *
+ * On an UART interrupt, 4 bytes of data come in on the interrupt
+ * endpoint. The bytes are 0xe8 IIR LSR MSR.
+ *
+ * The baudrate seems to be generated from the 12MHz crystal, using
+ * 4-times subsampling. So quot=12e6/(4*baud). Also see description
+ * of register E.
+ *
+ * Registers 0-7:
+ * These seem to be the same as for a regular 16450. The FCR is set
+ * to UART_FCR_DMA_SELECT (0x8), I guess to enable transfers between
+ * the UART and the USB bridge/DMA engine.
+ *
+ * Register 8:
+ * By trial and error, I found out that bit 0 enables hardware CTS,
+ * stopping TX when CTS is +5V. Bit 1 does the same for RTS, making
+ * RTS +5V when the 3116 cannot transfer the data to the USB bus
+ * (verified by disabling the reading URB). Note that as far as I can
+ * tell, the windows driver does NOT use this, so there might be some
+ * hardware bug or something.
+ *
+ * According to a patch provided here
+ * (http://lkml.org/lkml/2009/7/26/56), the ARK3116 can also be used
+ * as an IrDA dongle. Since I do not have such a thing, I could not
+ * investigate that aspect. However, I can speculate ;-).
+ *
+ * - IrDA encodes data differently than RS232. Most likely, one of
+ *   the bits in registers 9..E enables the IR ENDEC (encoder/decoder).
+ * - Depending on the IR transceiver, the input and output need to be
+ *   inverted, so there are probably bits for that as well.
+ * - IrDA is half-duplex, so there should be a bit for selecting that.
+ *
+ * This still leaves at least two registers unaccounted for. Perhaps
+ * The chip can do XON/XOFF or CRC in HW?
+ *
+ * Register 9:
+ * Set to 0x00 for IrDA, when the baudrate is initialised.
+ *
+ * Register A:
+ * Set to 0x01 for IrDA, at init.
+ *
+ * Register B:
+ * Set to 0x01 for IrDA, 0x00 for RS232, at init.
+ *
+ * Register C:
+ * Set to 00 for IrDA, at init.
+ *
+ * Register D:
+ * Set to 0x41 for IrDA, at init.
+ *
+ * Register E:
+ * Somekind of baudrate override. The windows driver seems to set
+ * this to 0x00 for normal baudrates, 0x01 for 460800, 0x02 for 921600.
+ * Since 460800 and 921600 cannot be obtained by dividing 3MHz by an integer,
+ * it could be somekind of subdivisor thingy.
+ * However,it does not seem to do anything: selecting 921600 (divisor 3,
+ * reg E=2), still gets 1 MHz. I also checked if registers 9, C or F would
+ * work, but they don't.
+ *
+ * Register F: unknown
+ */
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c
index a0467bc61627..1295e44e3f1c 100644
--- a/drivers/usb/serial/belkin_sa.c
+++ b/drivers/usb/serial/belkin_sa.c
@@ -103,7 +103,7 @@ static int  belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
                                         unsigned int set, unsigned int clear);
 
 
-static struct usb_device_id id_table_combined [] = {
+static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) },
         { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) },
         { USB_DEVICE(PERACOM_VID, PERACOM_PID) },
diff --git a/drivers/usb/serial/bus.c b/drivers/usb/serial/bus.c
index ba555c528cc6..7f547dc3a590 100644
--- a/drivers/usb/serial/bus.c
+++ b/drivers/usb/serial/bus.c
@@ -11,6 +11,7 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/tty.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index 59eff721fcc5..7e8e39818414 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -19,9 +19,11 @@
 #include <linux/init.h>
 #include <linux/tty.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include <linux/serial.h>
+#include <asm/unaligned.h>
 
 #define DEFAULT_BAUD_RATE 9600
 #define DEFAULT_TIMEOUT   1000
@@ -70,7 +72,7 @@
 
 static int debug;
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x4348, 0x5523) },
         { USB_DEVICE(0x1a86, 0x7523) },
         { },
@@ -392,16 +394,22 @@ static void ch341_break_ctl(struct tty_struct *tty, int break_state)
         struct usb_serial_port *port = tty->driver_data;
         int r;
         uint16_t reg_contents;
-        uint8_t break_reg[2];
+        uint8_t *break_reg;
 
         dbg("%s()", __func__);
 
+        break_reg = kmalloc(2, GFP_KERNEL);
+        if (!break_reg) {
+                dev_err(&port->dev, "%s - kmalloc failed\n", __func__);
+                return;
+        }
+
         r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
-                        ch341_break_reg, 0, break_reg, sizeof(break_reg));
+                        ch341_break_reg, 0, break_reg, 2);
         if (r < 0) {
-                printk(KERN_WARNING "%s: USB control read error whilst getting"
-                                " break register contents.\n", __FILE__);
-                return;
+                dev_err(&port->dev, "%s - USB control read error (%d)\n",
+                                __func__, r);
+                goto out;
         }
         dbg("%s - initial ch341 break register contents - reg1: %x, reg2: %x",
                         __func__, break_reg[0], break_reg[1]);
@@ -416,12 +424,14 @@ static void ch341_break_ctl(struct tty_struct *tty, int break_state)
         }
         dbg("%s - New ch341 break register contents - reg1: %x, reg2: %x",
                         __func__, break_reg[0], break_reg[1]);
-        reg_contents = (uint16_t)break_reg[0] | ((uint16_t)break_reg[1] << 8);
+        reg_contents = get_unaligned_le16(break_reg);
         r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
                         ch341_break_reg, reg_contents);
         if (r < 0)
-                printk(KERN_WARNING "%s: USB control write error whilst setting"
-                                " break register contents.\n", __FILE__);
+                dev_err(&port->dev, "%s - USB control write error (%d)\n",
+                                __func__, r);
+out:
+        kfree(break_reg);
 }
 
 static int ch341_tiocmset(struct tty_struct *tty, struct file *file,
diff --git a/drivers/usb/serial/console.c b/drivers/usb/serial/console.c
index b22ac3258523..f347da2ef00a 100644
--- a/drivers/usb/serial/console.c
+++ b/drivers/usb/serial/console.c
@@ -181,6 +181,7 @@ static int usb_console_setup(struct console *co, char *options)
         /* The console is special in terms of closing the device so
          * indicate this port is now acting as a system console. */
         port->console = 1;
+        port->port.console = 1;
 
         mutex_unlock(&serial->disc_mutex);
         return retval;
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index bd254ec97d14..ec9b0449ccf6 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -55,7 +55,7 @@ static int cp210x_carrier_raised(struct usb_serial_port *p);
 
 static int debug;
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
         { USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
         { USB_DEVICE(0x0745, 0x1000) }, /* CipherLab USB CCD Barcode Scanner 1000 */
@@ -91,11 +91,12 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
         { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
         { USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */
+        { USB_DEVICE(0x10C4, 0x81E8) }, /* Zephyr Bioharness */
         { USB_DEVICE(0x10C4, 0x81F2) }, /* C1007 HF band RFID controller */
         { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
         { USB_DEVICE(0x10C4, 0x822B) }, /* Modem EDGE(GSM) Comander 2 */
         { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demostration module */
-        { USB_DEVICE(0x10c4, 0x8293) }, /* Telegesys ETRX2USB */
+        { USB_DEVICE(0x10C4, 0x8293) }, /* Telegesys ETRX2USB */
         { USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
         { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
         { USB_DEVICE(0x10C4, 0x8382) }, /* Cygnal Integrated Products, Inc. */
@@ -312,11 +313,6 @@ static int cp210x_set_config(struct usb_serial_port *port, u8 request,
                 return -EPROTO;
         }
 
-        /* Single data value */
-        result = usb_control_msg(serial->dev,
-                        usb_sndctrlpipe(serial->dev, 0),
-                        request, REQTYPE_HOST_TO_DEVICE, data[0],
-                        0, NULL, 0, 300);
         return 0;
 }
 
@@ -612,7 +608,7 @@ static void cp210x_set_termios(struct tty_struct *tty,
                                 baud);
                 if (cp210x_set_config_single(port, CP210X_SET_BAUDDIV,
                                         ((BAUD_RATE_GEN_FREQ + baud/2) / baud))) {
-                        dbg("Baud rate requested not supported by device\n");
+                        dbg("Baud rate requested not supported by device");
                         baud = tty_termios_baud_rate(old_termios);
                 }
         }
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index b0f6402a91ca..f744ab7a3b19 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -70,7 +70,7 @@ static void cyberjack_read_int_callback(struct urb *urb);
 static void cyberjack_read_bulk_callback(struct urb *urb);
 static void cyberjack_write_bulk_callback(struct urb *urb);
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) },
         { }                     /* Terminating entry */
 };
@@ -391,11 +391,10 @@ static void cyberjack_read_bulk_callback(struct urb *urb)
 
         tty = tty_port_tty_get(&port->port);
         if (!tty) {
-                dbg("%s - ignoring since device not open\n", __func__);
+                dbg("%s - ignoring since device not open", __func__);
                 return;
         }
         if (urb->actual_length) {
-                tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index a591ebec0f89..e23c77925e7a 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -66,17 +66,15 @@
 #include <linux/serial.h>
 #include <linux/delay.h>
 #include <linux/uaccess.h>
+#include <asm/unaligned.h>
 
 #include "cypress_m8.h"
 
 
-#ifdef CONFIG_USB_SERIAL_DEBUG
-        static int debug = 1;
-#else
-        static int debug;
-#endif
+static int debug;
 static int stats;
 static int interval;
+static int unstable_bauds;
 
 /*
  * Version Information
@@ -89,24 +87,24 @@ static int interval;
 #define CYPRESS_BUF_SIZE        1024
 #define CYPRESS_CLOSING_WAIT    (30*HZ)
 
-static struct usb_device_id id_table_earthmate [] = {
+static const struct usb_device_id id_table_earthmate[] = {
         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) },
         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) },
         { }                                             /* Terminating entry */
 };
 
-static struct usb_device_id id_table_cyphidcomrs232 [] = {
+static const struct usb_device_id id_table_cyphidcomrs232[] = {
         { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) },
         { USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) },
         { }                                             /* Terminating entry */
 };
 
-static struct usb_device_id id_table_nokiaca42v2 [] = {
+static const struct usb_device_id id_table_nokiaca42v2[] = {
         { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) },
         { }                                             /* Terminating entry */
 };
 
-static struct usb_device_id id_table_combined [] = {
+static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) },
         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) },
         { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) },
@@ -154,7 +152,7 @@ struct cypress_private {
         int isthrottled;                   /* if throttled, discard reads */
         wait_queue_head_t delta_msr_wait;  /* used for TIOCMIWAIT */
         char prev_status, diff_status;     /* used for TIOCMIWAIT */
-        /* we pass a pointer to this as the arguement sent to
+        /* we pass a pointer to this as the argument sent to
            cypress_set_termios old_termios */
         struct ktermios tmp_termios;       /* stores the old termios settings */
 };
@@ -295,6 +293,9 @@ static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate)
         struct cypress_private *priv;
         priv = usb_get_serial_port_data(port);
 
+        if (unstable_bauds)
+                return new_rate;
+
         /*
          * The general purpose firmware for the Cypress M8 allows for
          * a maximum speed of 57600bps (I have no idea whether DeLorme
@@ -344,7 +345,8 @@ static int cypress_serial_control(struct tty_struct *tty,
 {
         int new_baudrate = 0, retval = 0, tries = 0;
         struct cypress_private *priv;
-        __u8 feature_buffer[5];
+        u8 *feature_buffer;
+        const unsigned int feature_len = 5;
         unsigned long flags;
 
         dbg("%s", __func__);
@@ -354,17 +356,18 @@ static int cypress_serial_control(struct tty_struct *tty,
         if (!priv->comm_is_ok)
                 return -ENODEV;
 
+        feature_buffer = kcalloc(feature_len, sizeof(u8), GFP_KERNEL);
+        if (!feature_buffer)
+                return -ENOMEM;
+
         switch (cypress_request_type) {
         case CYPRESS_SET_CONFIG:
-                new_baudrate = priv->baud_rate;
                 /* 0 means 'Hang up' so doesn't change the true bit rate */
-                if (baud_rate == 0)
-                        new_baudrate = priv->baud_rate;
-                /* Change of speed ? */
-                else if (baud_rate != priv->baud_rate) {
+                new_baudrate = priv->baud_rate;
+                if (baud_rate && baud_rate != priv->baud_rate) {
                         dbg("%s - baud rate is changing", __func__);
                         retval = analyze_baud_rate(port, baud_rate);
-                        if (retval >=  0) {
+                        if (retval >= 0) {
                                 new_baudrate = retval;
                                 dbg("%s - New baud rate set to %d",
                                     __func__, new_baudrate);
@@ -373,9 +376,8 @@ static int cypress_serial_control(struct tty_struct *tty,
                 dbg("%s - baud rate is being sent as %d",
                                         __func__, new_baudrate);
 
-                memset(feature_buffer, 0, sizeof(feature_buffer));
                 /* fill the feature_buffer with new configuration */
-                *((u_int32_t *)feature_buffer) = new_baudrate;
+                put_unaligned_le32(new_baudrate, feature_buffer);
                 feature_buffer[4] |= data_bits;   /* assign data bits in 2 bit space ( max 3 ) */
                 /* 1 bit gap */
                 feature_buffer[4] |= (stop_bits << 3);   /* assign stop bits in 1 bit space */
@@ -397,15 +399,15 @@ static int cypress_serial_control(struct tty_struct *tty,
                                         HID_REQ_SET_REPORT,
                                         USB_DIR_OUT | USB_RECIP_INTERFACE | USB_TYPE_CLASS,
                                         0x0300, 0, feature_buffer,
-                                        sizeof(feature_buffer), 500);
+                                        feature_len, 500);
 
                         if (tries++ >= 3)
                                 break;
 
-                } while (retval != sizeof(feature_buffer) &&
+                } while (retval != feature_len &&
                          retval != -ENODEV);
 
-                if (retval != sizeof(feature_buffer)) {
+                if (retval != feature_len) {
                         dev_err(&port->dev, "%s - failed sending serial "
                                 "line settings - %d\n", __func__, retval);
                         cypress_set_dead(port);
@@ -425,43 +427,42 @@ static int cypress_serial_control(struct tty_struct *tty,
                         /* Not implemented for this device,
                            and if we try to do it we're likely
                            to crash the hardware. */
-                        return -ENOTTY;
+                        retval = -ENOTTY;
+                        goto out;
                 }
                 dbg("%s - retreiving serial line settings", __func__);
-                /* set initial values in feature buffer */
-                memset(feature_buffer, 0, sizeof(feature_buffer));
-
                 do {
                         retval = usb_control_msg(port->serial->dev,
                                         usb_rcvctrlpipe(port->serial->dev, 0),
                                         HID_REQ_GET_REPORT,
                                         USB_DIR_IN | USB_RECIP_INTERFACE | USB_TYPE_CLASS,
                                         0x0300, 0, feature_buffer,
-                                        sizeof(feature_buffer), 500);
+                                        feature_len, 500);
 
                         if (tries++ >= 3)
                                 break;
-                } while (retval != sizeof(feature_buffer)
+                } while (retval != feature_len
                                                 && retval != -ENODEV);
 
-                if (retval != sizeof(feature_buffer)) {
+                if (retval != feature_len) {
                         dev_err(&port->dev, "%s - failed to retrieve serial "
                                 "line settings - %d\n", __func__, retval);
                         cypress_set_dead(port);
-                        return retval;
+                        goto out;
                 } else {
                         spin_lock_irqsave(&priv->lock, flags);
                         /* store the config in one byte, and later
                            use bit masks to check values */
                         priv->current_config = feature_buffer[4];
-                        priv->baud_rate = *((u_int32_t *)feature_buffer);
+                        priv->baud_rate = get_unaligned_le32(feature_buffer);
                         spin_unlock_irqrestore(&priv->lock, flags);
                 }
         }
         spin_lock_irqsave(&priv->lock, flags);
         ++priv->cmd_count;
         spin_unlock_irqrestore(&priv->lock, flags);
-
+out:
+        kfree(feature_buffer);
         return retval;
 } /* cypress_serial_control */
 
@@ -690,7 +691,6 @@ static void cypress_dtr_rts(struct usb_serial_port *port, int on)
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
         /* drop dtr and rts */
-        priv = usb_get_serial_port_data(port);
         spin_lock_irq(&priv->lock);
         if (on == 0)
                 priv->line_control = 0;
@@ -1307,13 +1307,9 @@ static void cypress_read_int_callback(struct urb *urb)
                 spin_unlock_irqrestore(&priv->lock, flags);
 
         /* process read if there is data other than line status */
-        if (tty && (bytes > i)) {
-                bytes = tty_buffer_request_room(tty, bytes);
-                for (; i < bytes ; ++i) {
-                        dbg("pushing byte number %d - %d - %c", i, data[i],
-                                        data[i]);
-                        tty_insert_flip_char(tty, data[i], tty_flag);
-                }
+        if (tty && bytes > i) {
+                tty_insert_flip_string_fixed_flag(tty, data + i,
+                                bytes - i, tty_flag);
                 tty_flip_buffer_push(tty);
         }
 
@@ -1325,9 +1321,9 @@ static void cypress_read_int_callback(struct urb *urb)
 continue_read:
         tty_kref_put(tty);
 
-        /* Continue trying to always read... unless the port has closed. */
+        /* Continue trying to always read */
 
-        if (port->port.count > 0 && priv->comm_is_ok) {
+        if (priv->comm_is_ok) {
                 usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev,
                                 usb_rcvintpipe(port->serial->dev,
                                         port->interrupt_in_endpointAddress),
@@ -1336,7 +1332,7 @@ continue_read:
                                 cypress_read_int_callback, port,
                                 priv->read_urb_interval);
                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
-                if (result) {
+                if (result && result != -EPERM) {
                         dev_err(&urb->dev->dev, "%s - failed resubmitting "
                                         "read urb, error %d\n", __func__,
                                         result);
@@ -1650,3 +1646,5 @@ module_param(stats, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(stats, "Enable statistics or not");
 module_param(interval, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(interval, "Overrides interrupt interval");
+module_param(unstable_bauds, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(unstable_bauds, "Allow unstable baud rates");
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 68e80be6b9e1..68b0aa5e516c 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -470,18 +470,18 @@ static int digi_read_oob_callback(struct urb *urb);
 
 static int debug;
 
-static struct usb_device_id id_table_combined [] = {
+static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
         { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
         { }                                             /* Terminating entry */
 };
 
-static struct usb_device_id id_table_2 [] = {
+static const struct usb_device_id id_table_2[] = {
         { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
         { }                                             /* Terminating entry */
 };
 
-static struct usb_device_id id_table_4 [] = {
+static const struct usb_device_id id_table_4[] = {
         { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
         { }                                             /* Terminating entry */
 };
@@ -1262,10 +1262,10 @@ static void digi_write_bulk_callback(struct urb *urb)
                 return;
         }
 
-        /* try to send any buffered data on this port, if it is open */
+        /* try to send any buffered data on this port */
         spin_lock(&priv->dp_port_lock);
         priv->dp_write_urb_in_use = 0;
-        if (port->port.count && priv->dp_out_buf_len > 0) {
+        if (priv->dp_out_buf_len > 0) {
                 *((unsigned char *)(port->write_urb->transfer_buffer))
                         = (unsigned char)DIGI_CMD_SEND_DATA;
                 *((unsigned char *)(port->write_urb->transfer_buffer) + 1)
@@ -1288,7 +1288,7 @@ static void digi_write_bulk_callback(struct urb *urb)
         schedule_work(&priv->dp_wakeup_work);
 
         spin_unlock(&priv->dp_port_lock);
-        if (ret)
+        if (ret && ret != -EPERM)
                 dev_err(&port->dev,
                         "%s: usb_submit_urb failed, ret=%d, port=%d\n",
                         __func__, ret, priv->dp_port_num);
@@ -1353,8 +1353,7 @@ static int digi_open(struct tty_struct *tty, struct usb_serial_port *port)
         struct digi_port *priv = usb_get_serial_port_data(port);
         struct ktermios not_termios;
 
-        dbg("digi_open: TOP: port=%d, open_count=%d",
-                priv->dp_port_num, port->port.count);
+        dbg("digi_open: TOP: port=%d", priv->dp_port_num);
 
         /* be sure the device is started up */
         if (digi_startup_device(port->serial) != 0)
@@ -1393,8 +1392,7 @@ static void digi_close(struct usb_serial_port *port)
         unsigned char buf[32];
         struct digi_port *priv = usb_get_serial_port_data(port);
 
-        dbg("digi_close: TOP: port=%d, open_count=%d",
-                priv->dp_port_num, port->port.count);
+        dbg("digi_close: TOP: port=%d", priv->dp_port_num);
 
         mutex_lock(&port->serial->disc_mutex);
         /* if disconnected, just clear flags */
@@ -1629,7 +1627,7 @@ static void digi_read_bulk_callback(struct urb *urb)
         /* continue read */
         urb->dev = port->serial->dev;
         ret = usb_submit_urb(urb, GFP_ATOMIC);
-        if (ret != 0) {
+        if (ret != 0 && ret != -EPERM) {
                 dev_err(&port->dev,
                         "%s: failed resubmitting urb, ret=%d, port=%d\n",
                         __func__, ret, priv->dp_port_num);
@@ -1658,12 +1656,11 @@ static int digi_read_inb_callback(struct urb *urb)
         int port_status = ((unsigned char *)urb->transfer_buffer)[2];
         unsigned char *data = ((unsigned char *)urb->transfer_buffer) + 3;
         int flag, throttled;
-        int i;
         int status = urb->status;
 
         /* do not process callbacks on closed ports */
         /* but do continue the read chain */
-        if (port->port.count == 0)
+        if (urb->status == -ENOENT)
                 return 0;
 
         /* short/multiple packet check */
@@ -1705,17 +1702,9 @@ static int digi_read_inb_callback(struct urb *urb)
 
                 /* data length is len-1 (one byte of len is port_status) */
                 --len;
-
-                len = tty_buffer_request_room(tty, len);
                 if (len > 0) {
-                        /* Hot path */
-                        if (flag == TTY_NORMAL)
-                                tty_insert_flip_string(tty, data, len);
-                        else {
-                                for (i = 0; i < len; i++)
-                                        tty_insert_flip_char(tty,
-                                                                data[i], flag);
-                        }
+                        tty_insert_flip_string_fixed_flag(tty, data, len,
+                                                                        flag);
                         tty_flip_buffer_push(tty);
                 }
         }
@@ -1776,8 +1765,7 @@ static int digi_read_oob_callback(struct urb *urb)
 
                 tty = tty_port_tty_get(&port->port);
                 rts = 0;
-                if (port->port.count)
-                        rts = tty->termios->c_cflag & CRTSCTS;
+                rts = tty->termios->c_cflag & CRTSCTS;
                 
                 if (opcode == DIGI_CMD_READ_INPUT_SIGNALS) {
                         spin_lock(&priv->dp_port_lock);
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index 7dd0e3eadbe6..5f740a1eacab 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -93,7 +93,7 @@ static void empeg_init_termios(struct tty_struct *tty);
 static void empeg_write_bulk_callback(struct urb *urb);
 static void empeg_read_bulk_callback(struct urb *urb);
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(EMPEG_VENDOR_ID, EMPEG_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
@@ -346,7 +346,6 @@ static void empeg_read_bulk_callback(struct urb *urb)
         tty = tty_port_tty_get(&port->port);
 
         if (urb->actual_length) {
-                tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
                 bytes_in += urb->actual_length;
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index ebcc6d0e2e91..1d7c4fac02e8 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -33,23 +33,24 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
+#include <linux/mutex.h>
 #include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/serial.h>
 #include <linux/usb/serial.h>
 #include "ftdi_sio.h"
+#include "ftdi_sio_ids.h"
 
 /*
  * Version Information
  */
 #define DRIVER_VERSION "v1.5.0"
-#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>"
+#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>, Andreas Mohr"
 #define DRIVER_DESC "USB FTDI Serial Converters Driver"
 
 static int debug;
@@ -87,10 +88,10 @@ struct ftdi_private {
 
         unsigned int latency;           /* latency setting in use */
         spinlock_t tx_lock;     /* spinlock for transmit state */
-        unsigned long tx_bytes;
         unsigned long tx_outstanding_bytes;
         unsigned long tx_outstanding_urbs;
         unsigned short max_packet_size;
+        struct mutex cfg_lock; /* Avoid mess by parallel calls of config ioctl() and change_speed() */
 };
 
 /* struct ftdi_sio_quirk is used by devices requiring special attention. */
@@ -144,10 +145,15 @@ static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
 
 
 
+/*
+ * Device ID not listed? Test via module params product/vendor or
+ * /sys/bus/usb/ftdi_sio/new_id, then send patch/report!
+ */
 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_CANDAPTER_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_NXTCAM_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) },
@@ -551,9 +557,16 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
         /*
-         * Due to many user requests for multiple ELV devices we enable
-         * them by default.
+         * ELV devices:
          */
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_USR_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_MSM1_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_KL100_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS550_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_EC3000_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS888_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_TWS550_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_FEM_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
@@ -570,11 +583,17 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_UTP8_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS444PC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_HS485_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_UMS100_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_TFD128_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_FM3RX_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS777_PID) },
         { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
         { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
         { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
@@ -595,9 +614,24 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_OCEANIC_PID) },
         { USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
+        { USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
         { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
         { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
         { USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USOPTL4_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USPTL4_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_2_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR2_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_485USB9F_2W_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_485USB9F_4W_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_232USB9M_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_485USBTB_2W_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_485USBTB_4W_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_TTL5USB9M_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_TTL3USB9M_PID) },
+        { USB_DEVICE(BANDB_VID, BANDB_ZZ_PROG1_USB_PID) },
         { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
         { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
@@ -624,6 +658,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
         { USB_DEVICE(EVOLUTION_VID, EVO_HYBRID_PID) },
         { USB_DEVICE(EVOLUTION_VID, EVO_RCM4_PID) },
+        { USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
@@ -682,6 +717,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
         { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
         { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
         { USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
@@ -703,6 +739,10 @@ static struct usb_device_id id_table_combined [] = {
                 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
         { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
+        { USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
+        { USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
+        { USB_DEVICE(FTDI_VID, MJSG_HD_RADIO_PID) },
+        { USB_DEVICE(FTDI_VID, MJSG_XM_RADIO_PID) },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
@@ -778,7 +818,7 @@ static struct usb_serial_driver ftdi_sio_device = {
                 .name =         "ftdi_sio",
         },
         .description =          "FTDI USB Serial Device",
-        .usb_driver =           &ftdi_driver ,
+        .usb_driver =           &ftdi_driver,
         .id_table =             id_table_combined,
         .num_ports =            1,
         .probe =                ftdi_sio_probe,
@@ -794,8 +834,8 @@ static struct usb_serial_driver ftdi_sio_device = {
         .chars_in_buffer =      ftdi_chars_in_buffer,
         .read_bulk_callback =   ftdi_read_bulk_callback,
         .write_bulk_callback =  ftdi_write_bulk_callback,
-        .tiocmget =             ftdi_tiocmget,
-        .tiocmset =             ftdi_tiocmset,
+        .tiocmget =             ftdi_tiocmget,
+        .tiocmset =             ftdi_tiocmset,
         .ioctl =                ftdi_ioctl,
         .set_termios =          ftdi_set_termios,
         .break_ctl =            ftdi_break_ctl,
@@ -901,7 +941,6 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set,
                                                         unsigned int clear)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        char *buf;
         unsigned urb_value;
         int rv;
 
@@ -910,10 +949,6 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set,
                 return 0;       /* no change */
         }
 
-        buf = kmalloc(1, GFP_NOIO);
-        if (!buf)
-                return -ENOMEM;
-
         clear &= ~set;  /* 'set' takes precedence over 'clear' */
         urb_value = 0;
         if (clear & TIOCM_DTR)
@@ -929,9 +964,7 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set,
                                FTDI_SIO_SET_MODEM_CTRL_REQUEST,
                                FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
                                urb_value, priv->interface,
-                               buf, 0, WDR_TIMEOUT);
-
-        kfree(buf);
+                               NULL, 0, WDR_TIMEOUT);
         if (rv < 0) {
                 dbg("%s Error from MODEM_CTRL urb: DTR %s, RTS %s",
                                 __func__,
@@ -1090,16 +1123,11 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
 static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        char *buf;
         __u16 urb_value;
         __u16 urb_index;
         __u32 urb_index_value;
         int rv;
 
-        buf = kmalloc(1, GFP_NOIO);
-        if (!buf)
-                return -ENOMEM;
-
         urb_index_value = get_ftdi_divisor(tty, port);
         urb_value = (__u16)urb_index_value;
         urb_index = (__u16)(urb_index_value >> 16);
@@ -1112,9 +1140,7 @@ static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
                             FTDI_SIO_SET_BAUDRATE_REQUEST,
                             FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
                             urb_value, urb_index,
-                            buf, 0, WDR_SHORT_TIMEOUT);
-
-        kfree(buf);
+                            NULL, 0, WDR_SHORT_TIMEOUT);
         return rv;
 }
 
@@ -1122,8 +1148,7 @@ static int write_latency_timer(struct usb_serial_port *port)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         struct usb_device *udev = port->serial->dev;
-        char buf[1];
-        int rv = 0;
+        int rv;
         int l = priv->latency;
 
         if (priv->flags & ASYNC_LOW_LATENCY)
@@ -1136,8 +1161,7 @@ static int write_latency_timer(struct usb_serial_port *port)
                              FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
                              FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
                              l, priv->interface,
-                             buf, 0, WDR_TIMEOUT);
-
+                             NULL, 0, WDR_TIMEOUT);
         if (rv < 0)
                 dev_err(&port->dev, "Unable to write latency timer: %i\n", rv);
         return rv;
@@ -1147,24 +1171,29 @@ static int read_latency_timer(struct usb_serial_port *port)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         struct usb_device *udev = port->serial->dev;
-        unsigned short latency = 0;
-        int rv = 0;
-
+        unsigned char *buf;
+        int rv;
 
         dbg("%s", __func__);
 
+        buf = kmalloc(1, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
         rv = usb_control_msg(udev,
                              usb_rcvctrlpipe(udev, 0),
                              FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
                              FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
                              0, priv->interface,
-                             (char *) &latency, 1, WDR_TIMEOUT);
-
-        if (rv < 0) {
+                             buf, 1, WDR_TIMEOUT);
+        if (rv < 0)
                 dev_err(&port->dev, "Unable to read latency timer: %i\n", rv);
-                return -EIO;
-        }
-        return latency;
+        else
+                priv->latency = buf[0];
+
+        kfree(buf);
+
+        return rv;
 }
 
 static int get_serial_info(struct usb_serial_port *port,
@@ -1195,7 +1224,7 @@ static int set_serial_info(struct tty_struct *tty,
         if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
                 return -EFAULT;
 
-        lock_kernel();
+        mutex_lock(&priv->cfg_lock);
         old_priv = *priv;
 
         /* Do error checking and permission checking */
@@ -1203,7 +1232,7 @@ static int set_serial_info(struct tty_struct *tty,
         if (!capable(CAP_SYS_ADMIN)) {
                 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
                      (priv->flags & ~ASYNC_USR_MASK))) {
-                        unlock_kernel();
+                        mutex_unlock(&priv->cfg_lock);
                         return -EPERM;
                 }
                 priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
@@ -1214,7 +1243,7 @@ static int set_serial_info(struct tty_struct *tty,
 
         if ((new_serial.baud_base != priv->baud_base) &&
             (new_serial.baud_base < 9600)) {
-                unlock_kernel();
+                mutex_unlock(&priv->cfg_lock);
                 return -EINVAL;
         }
 
@@ -1244,11 +1273,11 @@ check_and_exit:
              (priv->flags & ASYNC_SPD_MASK)) ||
             (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
              (old_priv.custom_divisor != priv->custom_divisor))) {
-                unlock_kernel();
                 change_speed(tty, port);
+                mutex_unlock(&priv->cfg_lock);
         }
         else
-                unlock_kernel();
+                mutex_unlock(&priv->cfg_lock);
         return 0;
 
 } /* set_serial_info */
@@ -1304,20 +1333,20 @@ static void ftdi_determine_type(struct usb_serial_port *port)
                                         __func__);
                 }
         } else if (version < 0x200) {
-                /* Old device.  Assume its the original SIO. */
+                /* Old device.  Assume it's the original SIO. */
                 priv->chip_type = SIO;
                 priv->baud_base = 12000000 / 16;
                 priv->write_offset = 1;
         } else if (version < 0x400) {
-                /* Assume its an FT8U232AM (or FT8U245AM) */
+                /* Assume it's an FT8U232AM (or FT8U245AM) */
                 /* (It might be a BM because of the iSerialNumber bug,
                  * but it will still work as an AM device.) */
                 priv->chip_type = FT8U232AM;
         } else if (version < 0x600) {
-                /* Assume its an FT232BM (or FT245BM) */
+                /* Assume it's an FT232BM (or FT245BM) */
                 priv->chip_type = FT232BM;
         } else {
-                /* Assume its an FT232R  */
+                /* Assume it's an FT232R */
                 priv->chip_type = FT232RL;
         }
         dev_info(&udev->dev, "Detected %s\n", ftdi_chip_name[priv->chip_type]);
@@ -1337,7 +1366,7 @@ static void ftdi_set_max_packet_size(struct usb_serial_port *port)
         struct usb_endpoint_descriptor *ep_desc = &interface->cur_altsetting->endpoint[1].desc;
 
         unsigned num_endpoints;
-        int i = 0;
+        int i;
 
         num_endpoints = interface->cur_altsetting->desc.bNumEndpoints;
         dev_info(&udev->dev, "Number of endpoints %d\n", num_endpoints);
@@ -1389,7 +1418,7 @@ static ssize_t store_latency_timer(struct device *dev,
         struct usb_serial_port *port = to_usb_serial_port(dev);
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         int v = simple_strtoul(valbuf, NULL, 10);
-        int rv = 0;
+        int rv;
 
         priv->latency = v;
         rv = write_latency_timer(port);
@@ -1406,9 +1435,8 @@ static ssize_t store_event_char(struct device *dev,
         struct usb_serial_port *port = to_usb_serial_port(dev);
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         struct usb_device *udev = port->serial->dev;
-        char buf[1];
         int v = simple_strtoul(valbuf, NULL, 10);
-        int rv = 0;
+        int rv;
 
         dbg("%s: setting event char = %i", __func__, v);
 
@@ -1417,8 +1445,7 @@ static ssize_t store_event_char(struct device *dev,
                              FTDI_SIO_SET_EVENT_CHAR_REQUEST,
                              FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
                              v, priv->interface,
-                             buf, 0, WDR_TIMEOUT);
-
+                             NULL, 0, WDR_TIMEOUT);
         if (rv < 0) {
                 dbg("Unable to write event character: %i", rv);
                 return -EIO;
@@ -1517,9 +1544,9 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
 
         kref_init(&priv->kref);
         spin_lock_init(&priv->tx_lock);
+        mutex_init(&priv->cfg_lock);
         init_waitqueue_head(&priv->delta_msr_wait);
-        /* This will push the characters through immediately rather
-           than queue a task to deliver them */
+
         priv->flags = ASYNC_LOW_LATENCY;
 
         if (quirk && quirk->port_probe)
@@ -1551,7 +1578,8 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
 
         ftdi_determine_type(port);
         ftdi_set_max_packet_size(port);
-        read_latency_timer(port);
+        if (read_latency_timer(port) < 0)
+                priv->latency = 16;
         create_sysfs_attrs(port);
         return 0;
 }
@@ -1596,8 +1624,6 @@ static int ftdi_NDI_device_setup(struct usb_serial *serial)
 {
         struct usb_device *udev = serial->dev;
         int latency = ndi_latency_timer;
-        int rv = 0;
-        char buf[1];
 
         if (latency == 0)
                 latency = 1;
@@ -1607,10 +1633,11 @@ static int ftdi_NDI_device_setup(struct usb_serial *serial)
         dbg("%s setting NDI device latency to %d", __func__, latency);
         dev_info(&udev->dev, "NDI device with a latency value of %d", latency);
 
-        rv = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+        /* FIXME: errors are not returned */
+        usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                                 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
                                 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
-                                latency, 0, buf, 0, WDR_TIMEOUT);
+                                latency, 0, NULL, 0, WDR_TIMEOUT);
         return 0;
 }
 
@@ -1686,7 +1713,7 @@ static int ftdi_submit_read_urb(struct usb_serial_port *port, gfp_t mem_flags)
                            urb->transfer_buffer_length,
                            ftdi_read_bulk_callback, port);
         result = usb_submit_urb(urb, mem_flags);
-        if (result)
+        if (result && result != -EPERM)
                 dev_err(&port->dev,
                         "%s - failed submitting read urb, error %d\n",
                                                         __func__, result);
@@ -1698,16 +1725,10 @@ static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
         struct usb_device *dev = port->serial->dev;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
-
-        int result = 0;
-        char buf[1]; /* Needed for the usb_control_msg I think */
+        int result;
 
         dbg("%s", __func__);
 
-        spin_lock_irqsave(&priv->tx_lock, flags);
-        priv->tx_bytes = 0;
-        spin_unlock_irqrestore(&priv->tx_lock, flags);
-
         write_latency_timer(port);
 
         /* No error checking for this (will get errors later anyway) */
@@ -1715,7 +1736,7 @@ static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
         usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                         FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
                         FTDI_SIO_RESET_SIO,
-                        priv->interface, buf, 0, WDR_TIMEOUT);
+                        priv->interface, NULL, 0, WDR_TIMEOUT);
 
         /* Termios defaults are set by usb_serial_init. We don't change
            port->tty->termios - this would lose speed settings, etc.
@@ -1743,7 +1764,6 @@ static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
 static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        char buf[1];
 
         mutex_lock(&port->serial->disc_mutex);
         if (!port->serial->disconnected) {
@@ -1752,7 +1772,7 @@ static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
                             usb_sndctrlpipe(port->serial->dev, 0),
                             FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                             FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
-                            0, priv->interface, buf, 0,
+                            0, priv->interface, NULL, 0,
                             WDR_TIMEOUT) < 0) {
                             dev_err(&port->dev, "error from flowcontrol urb\n");
                 }
@@ -1813,7 +1833,7 @@ static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port,
         spin_lock_irqsave(&priv->tx_lock, flags);
         if (priv->tx_outstanding_urbs > URB_UPPER_LIMIT) {
                 spin_unlock_irqrestore(&priv->tx_lock, flags);
-                dbg("%s - write limit hit\n", __func__);
+                dbg("%s - write limit hit", __func__);
                 return 0;
         }
         priv->tx_outstanding_urbs++;
@@ -1893,7 +1913,6 @@ static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port,
         } else {
                 spin_lock_irqsave(&priv->tx_lock, flags);
                 priv->tx_outstanding_bytes += count;
-                priv->tx_bytes += count;
                 spin_unlock_irqrestore(&priv->tx_lock, flags);
         }
 
@@ -2120,8 +2139,7 @@ static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        __u16 urb_value = 0;
-        char buf[1];
+        __u16 urb_value;
 
         /* break_state = -1 to turn on break, and 0 to turn off break */
         /* see drivers/char/tty_io.c to see it used */
@@ -2137,7 +2155,7 @@ static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
                         FTDI_SIO_SET_DATA_REQUEST,
                         FTDI_SIO_SET_DATA_REQUEST_TYPE,
                         urb_value , priv->interface,
-                        buf, 0, WDR_TIMEOUT) < 0) {
+                        NULL, 0, WDR_TIMEOUT) < 0) {
                 dev_err(&port->dev, "%s FAILED to enable/disable break state "
                         "(state was %d)\n", __func__, break_state);
         }
@@ -2161,7 +2179,6 @@ static void ftdi_set_termios(struct tty_struct *tty,
         struct ktermios *termios = tty->termios;
         unsigned int cflag = termios->c_cflag;
         __u16 urb_value; /* will hold the new flags */
-        char buf[1]; /* Perhaps I should dynamically alloc this? */
 
         /* Added for xon/xoff support */
         unsigned int iflag = termios->c_iflag;
@@ -2195,23 +2212,27 @@ static void ftdi_set_termios(struct tty_struct *tty,
 
         /* Set number of data bits, parity, stop bits */
 
-        termios->c_cflag &= ~CMSPAR;
-
         urb_value = 0;
         urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
                       FTDI_SIO_SET_DATA_STOP_BITS_1);
-        urb_value |= (cflag & PARENB ?
-                      (cflag & PARODD ? FTDI_SIO_SET_DATA_PARITY_ODD :
-                       FTDI_SIO_SET_DATA_PARITY_EVEN) :
-                      FTDI_SIO_SET_DATA_PARITY_NONE);
+        if (cflag & PARENB) {
+                if (cflag & CMSPAR)
+                        urb_value |= cflag & PARODD ?
+                                     FTDI_SIO_SET_DATA_PARITY_MARK :
+                                     FTDI_SIO_SET_DATA_PARITY_SPACE;
+                else
+                        urb_value |= cflag & PARODD ?
+                                     FTDI_SIO_SET_DATA_PARITY_ODD :
+                                     FTDI_SIO_SET_DATA_PARITY_EVEN;
+        } else {
+                urb_value |= FTDI_SIO_SET_DATA_PARITY_NONE;
+        }
         if (cflag & CSIZE) {
                 switch (cflag & CSIZE) {
-                case CS5: urb_value |= 5; dbg("Setting CS5"); break;
-                case CS6: urb_value |= 6; dbg("Setting CS6"); break;
                 case CS7: urb_value |= 7; dbg("Setting CS7"); break;
                 case CS8: urb_value |= 8; dbg("Setting CS8"); break;
                 default:
-                        dev_err(&port->dev, "CSIZE was set but not CS5-CS8\n");
+                        dev_err(&port->dev, "CSIZE was set but not CS7-CS8\n");
                 }
         }
 
@@ -2223,7 +2244,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                             FTDI_SIO_SET_DATA_REQUEST,
                             FTDI_SIO_SET_DATA_REQUEST_TYPE,
                             urb_value , priv->interface,
-                            buf, 0, WDR_SHORT_TIMEOUT) < 0) {
+                            NULL, 0, WDR_SHORT_TIMEOUT) < 0) {
                 dev_err(&port->dev, "%s FAILED to set "
                         "databits/stopbits/parity\n", __func__);
         }
@@ -2235,7 +2256,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                     0, priv->interface,
-                                    buf, 0, WDR_TIMEOUT) < 0) {
+                                    NULL, 0, WDR_TIMEOUT) < 0) {
                         dev_err(&port->dev,
                                 "%s error from disable flowcontrol urb\n",
                                 __func__);
@@ -2244,9 +2265,11 @@ static void ftdi_set_termios(struct tty_struct *tty,
                 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
         } else {
                 /* set the baudrate determined before */
+                mutex_lock(&priv->cfg_lock);
                 if (change_speed(tty, port))
                         dev_err(&port->dev, "%s urb failed to set baudrate\n",
                                 __func__);
+                mutex_unlock(&priv->cfg_lock);
                 /* Ensure RTS and DTR are raised when baudrate changed from 0 */
                 if (!old_termios || (old_termios->c_cflag & CBAUD) == B0)
                         set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
@@ -2261,7 +2284,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                     0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
-                                    buf, 0, WDR_TIMEOUT) < 0) {
+                                    NULL, 0, WDR_TIMEOUT) < 0) {
                         dev_err(&port->dev,
                                 "urb failed to set to rts/cts flow control\n");
                 }
@@ -2293,7 +2316,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                             urb_value , (FTDI_SIO_XON_XOFF_HS
                                                          | priv->interface),
-                                            buf, 0, WDR_TIMEOUT) < 0) {
+                                            NULL, 0, WDR_TIMEOUT) < 0) {
                                 dev_err(&port->dev, "urb failed to set to "
                                         "xon/xoff flow control\n");
                         }
@@ -2307,7 +2330,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                             0, priv->interface,
-                                            buf, 0, WDR_TIMEOUT) < 0) {
+                                            NULL, 0, WDR_TIMEOUT) < 0) {
                                 dev_err(&port->dev,
                                         "urb failed to clear flow control\n");
                         }
@@ -2321,21 +2344,22 @@ static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        unsigned char buf[2];
+        unsigned char *buf;
+        int len;
         int ret;
 
         dbg("%s TIOCMGET", __func__);
+
+        buf = kmalloc(2, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        /*
+         * The 8U232AM returns a two byte value (the SIO a 1 byte value) in
+         * the same format as the data returned from the in point.
+         */
         switch (priv->chip_type) {
         case SIO:
-                /* Request the status from the device */
-                ret = usb_control_msg(port->serial->dev,
-                           usb_rcvctrlpipe(port->serial->dev, 0),
-                           FTDI_SIO_GET_MODEM_STATUS_REQUEST,
-                           FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
-                           0, 0,
-                           buf, 1, WDR_TIMEOUT);
-                if (ret < 0)
-                        return ret;
+                len = 1;
                 break;
         case FT8U232AM:
         case FT232BM:
@@ -2343,27 +2367,30 @@ static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
         case FT232RL:
         case FT2232H:
         case FT4232H:
-                /* the 8U232AM returns a two byte value (the sio is a 1 byte
-                   value) - in the same format as the data returned from the in
-                   point */
-                ret = usb_control_msg(port->serial->dev,
-                                   usb_rcvctrlpipe(port->serial->dev, 0),
-                                   FTDI_SIO_GET_MODEM_STATUS_REQUEST,
-                                   FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
-                                   0, priv->interface,
-                                   buf, 2, WDR_TIMEOUT);
-                if (ret < 0)
-                        return ret;
+                len = 2;
                 break;
         default:
-                return -EFAULT;
+                ret = -EFAULT;
+                goto out;
         }
 
-        return  (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
+        ret = usb_control_msg(port->serial->dev,
+                        usb_rcvctrlpipe(port->serial->dev, 0),
+                        FTDI_SIO_GET_MODEM_STATUS_REQUEST,
+                        FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
+                        0, priv->interface,
+                        buf, len, WDR_TIMEOUT);
+        if (ret < 0)
+                goto out;
+
+        ret = (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
                 (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
                 (buf[0]  & FTDI_SIO_RI_MASK  ? TIOCM_RI  : 0) |
                 (buf[0]  & FTDI_SIO_RLSD_MASK ? TIOCM_CD  : 0) |
                 priv->last_dtr_rts;
+out:
+        kfree(buf);
+        return ret;
 }
 
 static int ftdi_tiocmset(struct tty_struct *tty, struct file *file,
@@ -2468,8 +2495,7 @@ void ftdi_unthrottle(struct tty_struct *tty)
         port->throttled = port->throttle_req = 0;
         spin_unlock_irqrestore(&port->lock, flags);
 
-        /* Resubmit urb if throttled and open. */
-        if (was_throttled && test_bit(ASYNCB_INITIALIZED, &port->port.flags))
+        if (was_throttled)
                 ftdi_submit_read_urb(port, GFP_KERNEL);
 }
 
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index 6f31e0d71898..ff9bf80327a3 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -1,7 +1,10 @@
 /*
- * Definitions for the FTDI USB Single Port Serial Converter -
+ * Driver definitions for the FTDI USB Single Port Serial Converter -
  * known as FTDI_SIO (Serial Input/Output application of the chipset)
  *
+ * For USB vendor/product IDs (VID/PID), please see ftdi_sio_ids.h
+ *
+ *
  * The example I have is known as the USC-1000 which is available from
  * http://www.dse.co.nz - cat no XH4214 It looks similar to this:
  * http://www.dansdata.com/usbser.htm but I can't be sure There are other
@@ -17,866 +20,7 @@
  * Bill Ryder - bryder@sgi.com formerly of Silicon Graphics, Inc.- wrote the
  * FTDI_SIO implementation.
  *
- * Philipp Gühring - pg@futureware.at - added the Device ID of the USB relais
- * from Rudolf Gugler
- *
- */
-
-#define FTDI_VID        0x0403  /* Vendor Id */
-#define FTDI_SIO_PID    0x8372  /* Product Id SIO application of 8U100AX  */
-#define FTDI_8U232AM_PID 0x6001 /* Similar device to SIO above */
-#define FTDI_8U232AM_ALT_PID 0x6006 /* FTDI's alternate PID for above */
-#define FTDI_8U2232C_PID 0x6010 /* Dual channel device */
-#define FTDI_232RL_PID  0xFBFA  /* Product ID for FT232RL */
-#define FTDI_4232H_PID 0x6011 /* Quad channel hi-speed device */
-#define FTDI_RELAIS_PID 0xFA10  /* Relais device from Rudolf Gugler */
-#define FTDI_NF_RIC_VID 0x0DCD  /* Vendor Id */
-#define FTDI_NF_RIC_PID 0x0001  /* Product Id */
-#define FTDI_USBX_707_PID 0xF857        /* ADSTech IR Blaster USBX-707 */
-
-/* Larsen and Brusgaard AltiTrack/USBtrack  */
-#define LARSENBRUSGAARD_VID             0x0FD8
-#define LB_ALTITRACK_PID                0x0001
-
-/* www.canusb.com Lawicel CANUSB device */
-#define FTDI_CANUSB_PID 0xFFA8 /* Product Id */
-
-/* AlphaMicro Components AMC-232USB01 device */
-#define FTDI_AMC232_PID 0xFF00 /* Product Id */
-
-/* www.candapter.com Ewert Energy Systems CANdapter device */
-#define FTDI_CANDAPTER_PID 0x9F80 /* 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
-
-
-/* www.starting-point-systems.com µChameleon device */
-#define FTDI_MICRO_CHAMELEON_PID        0xCAA0  /* Product Id */
-
-/* www.irtrans.de device */
-#define FTDI_IRTRANS_PID 0xFC60 /* Product Id */
-
-
-/* www.thoughttechnology.com/ TT-USB provide with procomp use ftdi_sio */
-#define FTDI_TTUSB_PID 0xFF20 /* Product Id */
-
-/* iPlus device */
-#define FTDI_IPLUS_PID 0xD070 /* Product Id */
-#define FTDI_IPLUS2_PID 0xD071 /* Product Id */
-
-/* DMX4ALL DMX Interfaces */
-#define FTDI_DMX4ALL 0xC850
-
-/* OpenDCC (www.opendcc.de) product id */
-#define FTDI_OPENDCC_PID        0xBFD8
-#define FTDI_OPENDCC_SNIFFER_PID        0xBFD9
-#define FTDI_OPENDCC_THROTTLE_PID       0xBFDA
-#define FTDI_OPENDCC_GATEWAY_PID        0xBFDB
-
-/* Sprog II (Andrew Crosland's SprogII DCC interface) */
-#define FTDI_SPROG_II           0xF0C8
-
-/* www.crystalfontz.com devices - thanx for providing free devices for evaluation ! */
-/* they use the ftdi chipset for the USB interface and the vendor id is the same */
-#define FTDI_XF_632_PID 0xFC08  /* 632: 16x2 Character Display */
-#define FTDI_XF_634_PID 0xFC09  /* 634: 20x4 Character Display */
-#define FTDI_XF_547_PID 0xFC0A  /* 547: Two line Display */
-#define FTDI_XF_633_PID 0xFC0B  /* 633: 16x2 Character Display with Keys */
-#define FTDI_XF_631_PID 0xFC0C  /* 631: 20x2 Character Display */
-#define FTDI_XF_635_PID 0xFC0D  /* 635: 20x4 Character Display */
-#define FTDI_XF_640_PID 0xFC0E  /* 640: Two line Display */
-#define FTDI_XF_642_PID 0xFC0F  /* 642: Two line Display */
-
-/* Video Networks Limited / Homechoice in the UK use an ftdi-based device for their 1Mb */
-/* broadband internet service.  The following PID is exhibited by the usb device supplied */
-/* (the VID is the standard ftdi vid (FTDI_VID) */
-#define FTDI_VNHCPCUSB_D_PID 0xfe38 /* Product Id */
-
-/*
- * PCDJ use ftdi based dj-controllers.  The following PID is for their DAC-2 device
- * http://www.pcdjhardware.com/DAC2.asp (PID sent by Wouter Paesen)
- * (the VID is the standard ftdi vid (FTDI_VID) */
-#define FTDI_PCDJ_DAC2_PID 0xFA88
-
-/*
- * The following are the values for the Matrix Orbital LCD displays,
- * which are the FT232BM ( similar to the 8U232AM )
- */
-#define FTDI_MTXORB_0_PID      0xFA00  /* Matrix Orbital Product Id */
-#define FTDI_MTXORB_1_PID      0xFA01  /* Matrix Orbital Product Id */
-#define FTDI_MTXORB_2_PID      0xFA02  /* Matrix Orbital Product Id */
-#define FTDI_MTXORB_3_PID      0xFA03  /* Matrix Orbital Product Id */
-#define FTDI_MTXORB_4_PID      0xFA04  /* Matrix Orbital Product Id */
-#define FTDI_MTXORB_5_PID      0xFA05  /* Matrix Orbital Product Id */
-#define FTDI_MTXORB_6_PID      0xFA06  /* Matrix Orbital Product Id */
-
-/* OOCDlink by Joern Kaipf <joernk@web.de>
- * (http://www.joernonline.de/dw/doku.php?id=start&idx=projects:oocdlink) */
-#define FTDI_OOCDLINK_PID       0xbaf8  /* Amontec JTAGkey */
-
-/*
- * 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 */
-#define INTERBIOMETRICS_VID              0x1209
-#define INTERBIOMETRICS_IOBOARD_PID      0x1002
-#define INTERBIOMETRICS_MINI_IOBOARD_PID 0x1006
-
-/*
- * The following are the values for the Perle Systems
- * UltraPort USB serial converters
- */
-#define FTDI_PERLE_ULTRAPORT_PID 0xF0C0 /* Perle UltraPort Product Id */
-
-/*
- * The following are the values for the Sealevel SeaLINK+ adapters.
- * (Original list sent by Tuan Hoang.  Ian Abbott renamed the macros and
- * removed some PIDs that don't seem to match any existing products.)
- */
-#define SEALEVEL_VID            0x0c52  /* Sealevel Vendor ID */
-#define SEALEVEL_2101_PID       0x2101  /* SeaLINK+232 (2101/2105) */
-#define SEALEVEL_2102_PID       0x2102  /* SeaLINK+485 (2102) */
-#define SEALEVEL_2103_PID       0x2103  /* SeaLINK+232I (2103) */
-#define SEALEVEL_2104_PID       0x2104  /* SeaLINK+485I (2104) */
-#define SEALEVEL_2106_PID       0x9020  /* SeaLINK+422 (2106) */
-#define SEALEVEL_2201_1_PID     0x2211  /* SeaPORT+2/232 (2201) Port 1 */
-#define SEALEVEL_2201_2_PID     0x2221  /* SeaPORT+2/232 (2201) Port 2 */
-#define SEALEVEL_2202_1_PID     0x2212  /* SeaPORT+2/485 (2202) Port 1 */
-#define SEALEVEL_2202_2_PID     0x2222  /* SeaPORT+2/485 (2202) Port 2 */
-#define SEALEVEL_2203_1_PID     0x2213  /* SeaPORT+2 (2203) Port 1 */
-#define SEALEVEL_2203_2_PID     0x2223  /* SeaPORT+2 (2203) Port 2 */
-#define SEALEVEL_2401_1_PID     0x2411  /* SeaPORT+4/232 (2401) Port 1 */
-#define SEALEVEL_2401_2_PID     0x2421  /* SeaPORT+4/232 (2401) Port 2 */
-#define SEALEVEL_2401_3_PID     0x2431  /* SeaPORT+4/232 (2401) Port 3 */
-#define SEALEVEL_2401_4_PID     0x2441  /* SeaPORT+4/232 (2401) Port 4 */
-#define SEALEVEL_2402_1_PID     0x2412  /* SeaPORT+4/485 (2402) Port 1 */
-#define SEALEVEL_2402_2_PID     0x2422  /* SeaPORT+4/485 (2402) Port 2 */
-#define SEALEVEL_2402_3_PID     0x2432  /* SeaPORT+4/485 (2402) Port 3 */
-#define SEALEVEL_2402_4_PID     0x2442  /* SeaPORT+4/485 (2402) Port 4 */
-#define SEALEVEL_2403_1_PID     0x2413  /* SeaPORT+4 (2403) Port 1 */
-#define SEALEVEL_2403_2_PID     0x2423  /* SeaPORT+4 (2403) Port 2 */
-#define SEALEVEL_2403_3_PID     0x2433  /* SeaPORT+4 (2403) Port 3 */
-#define SEALEVEL_2403_4_PID     0x2443  /* SeaPORT+4 (2403) Port 4 */
-#define SEALEVEL_2801_1_PID     0X2811  /* SeaLINK+8/232 (2801) Port 1 */
-#define SEALEVEL_2801_2_PID     0X2821  /* SeaLINK+8/232 (2801) Port 2 */
-#define SEALEVEL_2801_3_PID     0X2831  /* SeaLINK+8/232 (2801) Port 3 */
-#define SEALEVEL_2801_4_PID     0X2841  /* SeaLINK+8/232 (2801) Port 4 */
-#define SEALEVEL_2801_5_PID     0X2851  /* SeaLINK+8/232 (2801) Port 5 */
-#define SEALEVEL_2801_6_PID     0X2861  /* SeaLINK+8/232 (2801) Port 6 */
-#define SEALEVEL_2801_7_PID     0X2871  /* SeaLINK+8/232 (2801) Port 7 */
-#define SEALEVEL_2801_8_PID     0X2881  /* SeaLINK+8/232 (2801) Port 8 */
-#define SEALEVEL_2802_1_PID     0X2812  /* SeaLINK+8/485 (2802) Port 1 */
-#define SEALEVEL_2802_2_PID     0X2822  /* SeaLINK+8/485 (2802) Port 2 */
-#define SEALEVEL_2802_3_PID     0X2832  /* SeaLINK+8/485 (2802) Port 3 */
-#define SEALEVEL_2802_4_PID     0X2842  /* SeaLINK+8/485 (2802) Port 4 */
-#define SEALEVEL_2802_5_PID     0X2852  /* SeaLINK+8/485 (2802) Port 5 */
-#define SEALEVEL_2802_6_PID     0X2862  /* SeaLINK+8/485 (2802) Port 6 */
-#define SEALEVEL_2802_7_PID     0X2872  /* SeaLINK+8/485 (2802) Port 7 */
-#define SEALEVEL_2802_8_PID     0X2882  /* SeaLINK+8/485 (2802) Port 8 */
-#define SEALEVEL_2803_1_PID     0X2813  /* SeaLINK+8 (2803) Port 1 */
-#define SEALEVEL_2803_2_PID     0X2823  /* SeaLINK+8 (2803) Port 2 */
-#define SEALEVEL_2803_3_PID     0X2833  /* SeaLINK+8 (2803) Port 3 */
-#define SEALEVEL_2803_4_PID     0X2843  /* SeaLINK+8 (2803) Port 4 */
-#define SEALEVEL_2803_5_PID     0X2853  /* SeaLINK+8 (2803) Port 5 */
-#define SEALEVEL_2803_6_PID     0X2863  /* SeaLINK+8 (2803) Port 6 */
-#define SEALEVEL_2803_7_PID     0X2873  /* SeaLINK+8 (2803) Port 7 */
-#define SEALEVEL_2803_8_PID     0X2883  /* SeaLINK+8 (2803) Port 8 */
-
-/*
- * The following are the values for two KOBIL chipcard terminals.
- */
-#define KOBIL_VID               0x0d46  /* KOBIL Vendor ID */
-#define KOBIL_CONV_B1_PID       0x2020  /* KOBIL Konverter for B1 */
-#define KOBIL_CONV_KAAN_PID     0x2021  /* KOBIL_Konverter for KAAN */
-
-/*
- * Icom ID-1 digital transceiver
- */
-
-#define ICOM_ID1_VID            0x0C26
-#define ICOM_ID1_PID            0x0004
-
-/*
- * ASK.fr devices
- */
-#define FTDI_ASK_RDR400_PID     0xC991  /* ASK RDR 400 series card reader */
-
-/*
- * FTDI USB UART chips used in construction projects from the
- * Elektor Electronics magazine (http://elektor-electronics.co.uk)
- */
-#define ELEKTOR_VID             0x0C7D
-#define ELEKTOR_FT323R_PID      0x0005  /* RFID-Reader, issue 09-2006 */
-
-/*
- * DSS-20 Sync Station for Sony Ericsson P800
- */
-#define FTDI_DSS20_PID          0xFC82
-
-/*
- * Home Electronics (www.home-electro.com) USB gadgets
- */
-#define FTDI_HE_TIRA1_PID       0xFA78  /* Tira-1 IR transceiver */
-
-/* USB-UIRT - An infrared receiver and transmitter using the 8U232AM chip */
-/* http://home.earthlink.net/~jrhees/USBUIRT/index.htm */
-#define FTDI_USB_UIRT_PID       0xF850  /* Product Id */
-
-/* TNC-X USB-to-packet-radio adapter, versions prior to 3.0 (DLP module) */
-
-#define FTDI_TNC_X_PID          0xEBE0
-
-/*
- * ELV USB devices submitted by Christian Abt of ELV (www.elv.de).
- * All of these devices use FTDI's vendor ID (0x0403).
- *
- * The previously included PID for the UO 100 module was incorrect.
- * In fact, that PID was for ELV's UR 100 USB-RS232 converter (0xFB58).
- *
- * Armin Laeuger originally sent the PID for the UM 100 module.
- */
-#define FTDI_R2000KU_TRUE_RNG   0xFB80  /* R2000KU TRUE RNG */
-#define FTDI_ELV_UR100_PID      0xFB58  /* USB-RS232-Umsetzer (UR 100) */
-#define FTDI_ELV_UM100_PID      0xFB5A  /* USB-Modul UM 100 */
-#define FTDI_ELV_UO100_PID      0xFB5B  /* USB-Modul UO 100 */
-#define FTDI_ELV_ALC8500_PID    0xF06E  /* ALC 8500 Expert */
-/* Additional ELV PIDs that default to using the FTDI D2XX drivers on
- * MS Windows, rather than the FTDI Virtual Com Port drivers.
- * Maybe these will be easier to use with the libftdi/libusb user-space
- * drivers, or possibly the Comedi drivers in some cases. */
-#define FTDI_ELV_CLI7000_PID    0xFB59  /* Computer-Light-Interface (CLI 7000) */
-#define FTDI_ELV_PPS7330_PID    0xFB5C  /* Processor-Power-Supply (PPS 7330) */
-#define FTDI_ELV_TFM100_PID     0xFB5D  /* Temperartur-Feuchte Messgeraet (TFM 100) */
-#define FTDI_ELV_UDF77_PID      0xFB5E  /* USB DCF Funkurh (UDF 77) */
-#define FTDI_ELV_UIO88_PID      0xFB5F  /* USB-I/O Interface (UIO 88) */
-#define FTDI_ELV_UAD8_PID       0xF068  /* USB-AD-Wandler (UAD 8) */
-#define FTDI_ELV_UDA7_PID       0xF069  /* USB-DA-Wandler (UDA 7) */
-#define FTDI_ELV_USI2_PID       0xF06A  /* USB-Schrittmotoren-Interface (USI 2) */
-#define FTDI_ELV_T1100_PID      0xF06B  /* Thermometer (T 1100) */
-#define FTDI_ELV_PCD200_PID     0xF06C  /* PC-Datenlogger (PCD 200) */
-#define FTDI_ELV_ULA200_PID     0xF06D  /* USB-LCD-Ansteuerung (ULA 200) */
-#define FTDI_ELV_FHZ1000PC_PID  0xF06F  /* FHZ 1000 PC */
-#define FTDI_ELV_CSI8_PID       0xE0F0  /* Computer-Schalt-Interface (CSI 8) */
-#define FTDI_ELV_EM1000DL_PID   0xE0F1  /* PC-Datenlogger fuer Energiemonitor (EM 1000 DL) */
-#define FTDI_ELV_PCK100_PID     0xE0F2  /* PC-Kabeltester (PCK 100) */
-#define FTDI_ELV_RFP500_PID     0xE0F3  /* HF-Leistungsmesser (RFP 500) */
-#define FTDI_ELV_FS20SIG_PID    0xE0F4  /* Signalgeber (FS 20 SIG) */
-#define FTDI_ELV_WS300PC_PID    0xE0F6  /* PC-Wetterstation (WS 300 PC) */
-#define FTDI_ELV_FHZ1300PC_PID  0xE0E8  /* FHZ 1300 PC */
-#define FTDI_ELV_WS500_PID      0xE0E9  /* PC-Wetterstation (WS 500) */
-#define FTDI_ELV_HS485_PID      0xE0EA  /* USB to RS-485 adapter */
-#define FTDI_ELV_EM1010PC_PID   0xE0EF  /* Engery monitor EM 1010 PC */
-#define FTDI_PHI_FISCO_PID      0xE40B  /* PHI Fisco USB to Serial cable */
-
-/*
- * Definitions for ID TECH (www.idt-net.com) devices
- */
-#define IDTECH_VID              0x0ACD  /* ID TECH Vendor ID */
-#define IDTECH_IDT1221U_PID     0x0300  /* IDT1221U USB to RS-232 adapter */
-
-/*
- * Definitions for Omnidirectional Control Technology, Inc. devices
- */
-#define OCT_VID                 0x0B39  /* OCT vendor ID */
-/* Note: OCT US101 is also rebadged as Dick Smith Electronics (NZ) XH6381 */
-/* Also rebadged as Dick Smith Electronics (Aus) XH6451 */
-/* Also rebadged as SIIG Inc. model US2308 hardware version 1 */
-#define OCT_US101_PID           0x0421  /* OCT US101 USB to RS-232 */
-
-/* an infrared receiver for user access control with IR tags */
-#define FTDI_PIEGROUP_PID       0xF208  /* Product Id */
-
-/*
- * Definitions for Artemis astronomical USB based cameras
- * Check it at http://www.artemisccd.co.uk/
- */
-#define FTDI_ARTEMIS_PID        0xDF28  /* All Artemis Cameras */
-
-/*
- * Definitions for ATIK Instruments astronomical USB based cameras
- * Check it at http://www.atik-instruments.com/
- */
-#define FTDI_ATIK_ATK16_PID     0xDF30  /* ATIK ATK-16 Grayscale Camera */
-#define FTDI_ATIK_ATK16C_PID    0xDF32  /* ATIK ATK-16C Colour Camera */
-#define FTDI_ATIK_ATK16HR_PID   0xDF31  /* ATIK ATK-16HR Grayscale Camera */
-#define FTDI_ATIK_ATK16HRC_PID  0xDF33  /* ATIK ATK-16HRC Colour Camera */
-#define FTDI_ATIK_ATK16IC_PID   0xDF35  /* ATIK ATK-16IC Grayscale Camera */
-
-/*
- * Protego product ids
- */
-#define PROTEGO_SPECIAL_1       0xFC70  /* special/unknown device */
-#define PROTEGO_R2X0            0xFC71  /* R200-USB TRNG unit (R210, R220, and R230) */
-#define PROTEGO_SPECIAL_3       0xFC72  /* special/unknown device */
-#define PROTEGO_SPECIAL_4       0xFC73  /* special/unknown device */
-
-/*
- * Gude Analog- und Digitalsysteme GmbH
- */
-#define FTDI_GUDEADS_E808_PID    0xE808
-#define FTDI_GUDEADS_E809_PID    0xE809
-#define FTDI_GUDEADS_E80A_PID    0xE80A
-#define FTDI_GUDEADS_E80B_PID    0xE80B
-#define FTDI_GUDEADS_E80C_PID    0xE80C
-#define FTDI_GUDEADS_E80D_PID    0xE80D
-#define FTDI_GUDEADS_E80E_PID    0xE80E
-#define FTDI_GUDEADS_E80F_PID    0xE80F
-#define FTDI_GUDEADS_E888_PID    0xE888  /* Expert ISDN Control USB */
-#define FTDI_GUDEADS_E889_PID    0xE889  /* USB RS-232 OptoBridge */
-#define FTDI_GUDEADS_E88A_PID    0xE88A
-#define FTDI_GUDEADS_E88B_PID    0xE88B
-#define FTDI_GUDEADS_E88C_PID    0xE88C
-#define FTDI_GUDEADS_E88D_PID    0xE88D
-#define FTDI_GUDEADS_E88E_PID    0xE88E
-#define FTDI_GUDEADS_E88F_PID    0xE88F
-
-/*
- * Linx Technologies product ids
- */
-#define LINX_SDMUSBQSS_PID      0xF448  /* Linx SDM-USB-QS-S */
-#define LINX_MASTERDEVEL2_PID   0xF449   /* Linx Master Development 2.0 */
-#define LINX_FUTURE_0_PID   0xF44A   /* Linx future device */
-#define LINX_FUTURE_1_PID   0xF44B   /* Linx future device */
-#define LINX_FUTURE_2_PID   0xF44C   /* Linx future device */
-
-/* CCS Inc. ICDU/ICDU40 product ID - the FT232BM is used in an in-circuit-debugger */
-/* unit for PIC16's/PIC18's */
-#define FTDI_CCSICDU20_0_PID    0xF9D0
-#define FTDI_CCSICDU40_1_PID    0xF9D1
-#define FTDI_CCSMACHX_2_PID     0xF9D2
-#define FTDI_CCSLOAD_N_GO_3_PID 0xF9D3
-#define FTDI_CCSICDU64_4_PID    0xF9D4
-#define FTDI_CCSPRIME8_5_PID    0xF9D5
-
-/* Inside Accesso contactless reader (http://www.insidefr.com) */
-#define INSIDE_ACCESSO          0xFAD0
-
-/*
- * Intrepid Control Systems (http://www.intrepidcs.com/) ValueCAN and NeoVI
- */
-#define INTREPID_VID            0x093C
-#define INTREPID_VALUECAN_PID   0x0601
-#define INTREPID_NEOVI_PID      0x0701
-
-/*
- * Falcom Wireless Communications GmbH
- */
-#define FALCOM_VID              0x0F94  /* Vendor Id */
-#define FALCOM_TWIST_PID        0x0001  /* Falcom Twist USB GPRS modem */
-#define FALCOM_SAMBA_PID        0x0005  /* Falcom Samba USB GPRS modem */
-
-/*
- * SUUNTO product ids
- */
-#define FTDI_SUUNTO_SPORTS_PID  0xF680  /* Suunto Sports instrument */
-
-/*
- * Oceanic product ids
- */
-#define FTDI_OCEANIC_PID        0xF460  /* Oceanic dive instrument */
-
-/*
- * TTi (Thurlby Thandar Instruments)
- */
-#define TTI_VID                 0x103E  /* Vendor Id */
-#define TTI_QL355P_PID          0x03E8  /* TTi QL355P power supply */
-
-/*
- * Definitions for B&B Electronics products.
- */
-#define BANDB_VID               0x0856  /* B&B Electronics Vendor ID */
-#define BANDB_USOTL4_PID        0xAC01  /* USOTL4 Isolated RS-485 Converter */
-#define BANDB_USTL4_PID         0xAC02  /* USTL4 RS-485 Converter */
-#define BANDB_USO9ML2_PID       0xAC03  /* USO9ML2 Isolated RS-232 Converter */
-
-/*
- * RM Michaelides CANview USB (http://www.rmcan.com)
- * CAN fieldbus interface adapter, added by port GmbH www.port.de)
- * Ian Abbott changed the macro names for consistency.
- */
-#define FTDI_RM_CANVIEW_PID     0xfd60  /* Product Id */
-
-/*
- * EVER Eco Pro UPS (http://www.ever.com.pl/)
- */
-
-#define EVER_ECO_PRO_CDS        0xe520  /* RS-232 converter */
-
-/*
- * 4N-GALAXY.DE PIDs for CAN-USB, USB-RS232, USB-RS422, USB-RS485,
- * USB-TTY activ, USB-TTY passiv.  Some PIDs are used by several devices
- * and I'm not entirely sure which are used by which.
- */
-#define FTDI_4N_GALAXY_DE_1_PID 0xF3C0
-#define FTDI_4N_GALAXY_DE_2_PID 0xF3C1
-
-/*
- * Mobility Electronics products.
- */
-#define MOBILITY_VID                    0x1342
-#define MOBILITY_USB_SERIAL_PID         0x0202  /* EasiDock USB 200 serial */
-
-/*
- * microHAM product IDs (http://www.microham.com).
- * Submitted by Justin Burket (KL1RL) <zorton@jtan.com>
- * and Mike Studer (K6EEP) <k6eep@hamsoftware.org>.
- * Ian Abbott <abbotti@mev.co.uk> added a few more from the driver INF file.
- */
-#define FTDI_MHAM_KW_PID 0xEEE8         /* USB-KW interface */
-#define FTDI_MHAM_YS_PID 0xEEE9         /* USB-YS interface */
-#define FTDI_MHAM_Y6_PID 0xEEEA         /* USB-Y6 interface */
-#define FTDI_MHAM_Y8_PID 0xEEEB         /* USB-Y8 interface */
-#define FTDI_MHAM_IC_PID 0xEEEC         /* USB-IC interface */
-#define FTDI_MHAM_DB9_PID 0xEEED        /* USB-DB9 interface */
-#define FTDI_MHAM_RS232_PID 0xEEEE      /* USB-RS232 interface */
-#define FTDI_MHAM_Y9_PID 0xEEEF         /* USB-Y9 interface */
-
-/*
- * Active Robots product ids.
- */
-#define FTDI_ACTIVE_ROBOTS_PID  0xE548  /* USB comms board */
-
-/*
- * Xsens Technologies BV products (http://www.xsens.com).
- */
-#define XSENS_CONVERTER_0_PID   0xD388
-#define XSENS_CONVERTER_1_PID   0xD389
-#define XSENS_CONVERTER_2_PID   0xD38A
-#define XSENS_CONVERTER_3_PID   0xD38B
-#define XSENS_CONVERTER_4_PID   0xD38C
-#define XSENS_CONVERTER_5_PID   0xD38D
-#define XSENS_CONVERTER_6_PID   0xD38E
-#define XSENS_CONVERTER_7_PID   0xD38F
-
-/*
- * Teratronik product ids.
- * Submitted by O. Wölfelschneider.
- */
-#define FTDI_TERATRONIK_VCP_PID  0xEC88 /* Teratronik device (preferring VCP driver on windows) */
-#define FTDI_TERATRONIK_D2XX_PID 0xEC89 /* Teratronik device (preferring D2XX driver on windows) */
-
-/*
- * Evolution Robotics products (http://www.evolution.com/).
- * Submitted by Shawn M. Lavelle.
- */
-#define EVOLUTION_VID           0xDEEE  /* Vendor ID */
-#define EVOLUTION_ER1_PID       0x0300  /* ER1 Control Module */
-#define EVO_8U232AM_PID 0x02FF  /* Evolution robotics RCM2 (FT232AM)*/
-#define EVO_HYBRID_PID          0x0302  /* Evolution robotics RCM4 PID (FT232BM)*/
-#define EVO_RCM4_PID            0x0303  /* Evolution robotics RCM4 PID */
-
-/* Pyramid Computer GmbH */
-#define FTDI_PYRAMID_PID        0xE6C8  /* Pyramid Appliance Display */
-
-/*
- * NDI (www.ndigital.com) product ids
- */
-#define FTDI_NDI_HUC_PID                0xDA70  /* NDI Host USB Converter */
-#define FTDI_NDI_SPECTRA_SCU_PID        0xDA71  /* NDI Spectra SCU */
-#define FTDI_NDI_FUTURE_2_PID           0xDA72  /* NDI future device #2 */
-#define FTDI_NDI_FUTURE_3_PID           0xDA73  /* NDI future device #3 */
-#define FTDI_NDI_AURORA_SCU_PID         0xDA74  /* NDI Aurora SCU */
-
-/*
- * Posiflex inc retail equipment (http://www.posiflex.com.tw)
- */
-#define POSIFLEX_VID            0x0d3a  /* Vendor ID */
-#define POSIFLEX_PP7000_PID     0x0300  /* PP-7000II thermal printer */
-
-/*
- * Westrex International devices submitted by Cory Lee
- */
-#define FTDI_WESTREX_MODEL_777_PID      0xDC00  /* Model 777 */
-#define FTDI_WESTREX_MODEL_8900F_PID    0xDC01  /* Model 8900F */
-
-/*
- * RR-CirKits LocoBuffer USB (http://www.rr-cirkits.com)
- */
-#define FTDI_RRCIRKITS_LOCOBUFFER_PID   0xc7d0  /* LocoBuffer USB */
-
-/*
- * Eclo (http://www.eclo.pt/) product IDs.
- * PID 0xEA90 submitted by Martin Grill.
- */
-#define FTDI_ECLO_COM_1WIRE_PID 0xEA90  /* COM to 1-Wire USB adaptor */
-
-/*
- * Papouch products (http://www.papouch.com/)
- * Submitted by Folkert van Heusden
- */
-
-#define PAPOUCH_VID                     0x5050  /* Vendor ID */
-#define PAPOUCH_TMU_PID                 0x0400  /* TMU USB Thermometer */
-#define PAPOUCH_QUIDO4x4_PID            0x0900  /* Quido 4/4 Module */
-
-/*
- * ACG Identification Technologies GmbH products (http://www.acg.de/).
- * Submitted by anton -at- goto10 -dot- org.
  */
-#define FTDI_ACG_HFDUAL_PID             0xDD20  /* HF Dual ISO Reader (RFID) */
-
-/*
- * Yost Engineering, Inc. products (www.yostengineering.com).
- * PID 0xE050 submitted by Aaron Prose.
- */
-#define FTDI_YEI_SERVOCENTER31_PID      0xE050  /* YEI ServoCenter3.1 USB */
-
-/*
- * ThorLabs USB motor drivers
- */
-#define FTDI_THORLABS_PID               0xfaf0 /* ThorLabs USB motor drivers */
-
-/*
- * Testo products (http://www.testo.com/)
- * Submitted by Colin Leroy
- */
-#define TESTO_VID                       0x128D
-#define TESTO_USB_INTERFACE_PID         0x0001
-
-/*
- * Gamma Scout (http://gamma-scout.com/). Submitted by rsc@runtux.com.
- */
-#define FTDI_GAMMA_SCOUT_PID            0xD678  /* Gamma Scout online */
-
-/*
- * Tactrix OpenPort (ECU) devices.
- * OpenPort 1.3M submitted by Donour Sizemore.
- * OpenPort 1.3S and 1.3U submitted by Ian Abbott.
- */
-#define FTDI_TACTRIX_OPENPORT_13M_PID   0xCC48  /* OpenPort 1.3 Mitsubishi */
-#define FTDI_TACTRIX_OPENPORT_13S_PID   0xCC49  /* OpenPort 1.3 Subaru */
-#define FTDI_TACTRIX_OPENPORT_13U_PID   0xCC4A  /* OpenPort 1.3 Universal */
-
-/*
- * Telldus Technologies
- */
-#define TELLDUS_VID                     0x1781  /* Vendor ID */
-#define TELLDUS_TELLSTICK_PID           0x0C30  /* RF control dongle 433 MHz using FT232RL */
-
-/*
- * IBS elektronik product ids
- * Submitted by Thomas Schleusener
- */
-#define FTDI_IBS_US485_PID      0xff38  /* IBS US485 (USB<-->RS422/485 interface) */
-#define FTDI_IBS_PICPRO_PID     0xff39  /* IBS PIC-Programmer */
-#define FTDI_IBS_PCMCIA_PID     0xff3a  /* IBS Card reader for PCMCIA SRAM-cards */
-#define FTDI_IBS_PK1_PID        0xff3b  /* IBS PK1 - Particel counter */
-#define FTDI_IBS_RS232MON_PID   0xff3c  /* IBS RS232 - Monitor */
-#define FTDI_IBS_APP70_PID      0xff3d  /* APP 70 (dust monitoring system) */
-#define FTDI_IBS_PEDO_PID       0xff3e  /* IBS PEDO-Modem (RF modem 868.35 MHz) */
-#define FTDI_IBS_PROD_PID       0xff3f  /* future device */
-
-/*
- *  MaxStream devices   www.maxstream.net
- */
-#define FTDI_MAXSTREAM_PID      0xEE18  /* Xbee PKG-U Module */
-
-/* Olimex */
-#define OLIMEX_VID                      0x15BA
-#define OLIMEX_ARM_USB_OCD_PID          0x0003
-
-/* Luminary Micro Stellaris Boards, VID = FTDI_VID */
-/* FTDI 2332C Dual channel device, side A=245 FIFO (JTAG), Side B=RS232 UART */
-#define LMI_LM3S_DEVEL_BOARD_PID        0xbcd8
-#define LMI_LM3S_EVAL_BOARD_PID         0xbcd9
-
-/* www.elsterelectricity.com Elster Unicom III Optical Probe */
-#define FTDI_ELSTER_UNICOM_PID          0xE700 /* Product Id */
-
-/*
- * The Mobility Lab (TML)
- * Submitted by Pierre Castella
- */
-#define TML_VID                 0x1B91  /* Vendor ID */
-#define TML_USB_SERIAL_PID      0x0064  /* USB - Serial Converter */
-
-/* Propox devices */
-#define FTDI_PROPOX_JTAGCABLEII_PID     0xD738
-
-/* Rig Expert Ukraine devices */
-#define FTDI_REU_TINY_PID               0xED22  /* RigExpert Tiny */
-
-/* Domintell products  http://www.domintell.com */
-#define FTDI_DOMINTELL_DGQG_PID 0xEF50  /* Master */
-#define FTDI_DOMINTELL_DUSB_PID 0xEF51  /* DUSB01 module */
-
-/* Alti-2 products  http://www.alti-2.com */
-#define ALTI2_VID       0x1BC9
-#define ALTI2_N3_PID    0x6001  /* Neptune 3 */
 
 /* Commands */
 #define FTDI_SIO_RESET          0 /* Reset the port */
@@ -884,98 +28,18 @@
 #define FTDI_SIO_SET_FLOW_CTRL  2 /* Set flow control register */
 #define FTDI_SIO_SET_BAUD_RATE  3 /* Set baud rate */
 #define FTDI_SIO_SET_DATA       4 /* Set the data characteristics of the port */
-#define FTDI_SIO_GET_MODEM_STATUS       5 /* Retrieve current value of modern status register */
+#define FTDI_SIO_GET_MODEM_STATUS       5 /* Retrieve current value of modem status register */
 #define FTDI_SIO_SET_EVENT_CHAR 6 /* Set the event character */
 #define FTDI_SIO_SET_ERROR_CHAR 7 /* Set the error character */
 #define FTDI_SIO_SET_LATENCY_TIMER      9 /* Set the latency timer */
 #define FTDI_SIO_GET_LATENCY_TIMER      10 /* Get the latency timer */
 
-/* Interface indicies for FT2232, FT2232H and FT4232H devices*/
+/* Interface indices for FT2232, FT2232H and FT4232H devices */
 #define INTERFACE_A             1
 #define INTERFACE_B             2
 #define INTERFACE_C             3
 #define INTERFACE_D             4
 
-/*
- * FIC / OpenMoko, Inc. http://wiki.openmoko.org/wiki/Neo1973_Debug_Board_v3
- * Submitted by Harald Welte <laforge@openmoko.org>
- */
-#define FIC_VID                 0x1457
-#define FIC_NEO1973_DEBUG_PID   0x5118
-
-/*
- * RATOC REX-USB60F
- */
-#define RATOC_VENDOR_ID         0x0584
-#define RATOC_PRODUCT_ID_USB60F 0xb020
-
-/*
- * DIEBOLD BCS SE923
- */
-#define DIEBOLD_BCS_SE923_PID   0xfb99
-
-/*
- * Atmel STK541
- */
-#define ATMEL_VID               0x03eb /* Vendor ID */
-#define STK541_PID              0x2109 /* Zigbee Controller */
-
-/*
- * Dresden Elektronic Sensor Terminal Board
- */
-#define DE_VID                  0x1cf1 /* Vendor ID */
-#define STB_PID                 0x0001 /* Sensor Terminal Board */
-#define WHT_PID                 0x0004 /* Wireless Handheld Terminal */
-
-/*
- * Blackfin gnICE JTAG
- * http://docs.blackfin.uclinux.org/doku.php?id=hw:jtag:gnice
- */
-#define ADI_VID                 0x0456
-#define ADI_GNICE_PID           0xF000
-#define ADI_GNICEPLUS_PID       0xF001
-
-/*
- * JETI SPECTROMETER SPECBOS 1201
- * http://www.jeti.com/products/sys/scb/scb1201.php
- */
-#define JETI_VID                0x0c6c
-#define JETI_SPC1201_PID        0x04b2
-
-/*
- * Marvell SheevaPlug
- */
-#define MARVELL_VID             0x9e88
-#define MARVELL_SHEEVAPLUG_PID  0x9e8f
-
-#define FTDI_TURTELIZER_PID     0xBDC8 /* JTAG/RS-232 adapter by egnite GmBH */
-
-/*
- * GN Otometrics (http://www.otometrics.com)
- * Submitted by Ville Sundberg.
- */
-#define GN_OTOMETRICS_VID       0x0c33  /* Vendor ID */
-#define AURICAL_USB_PID         0x0010  /* Aurical USB Audiometer */
-
-/*
- * Bayer Ascensia Contour blood glucose meter USB-converter cable.
- * http://winglucofacts.com/cables/
- */
-#define BAYER_VID                      0x1A79
-#define BAYER_CONTOUR_CABLE_PID        0x6001
-
-/*
- * Marvell OpenRD Base, Client
- * http://www.open-rd.org
- * OpenRD Base, Client use VID 0x0403
- */
-#define MARVELL_OPENRD_PID      0x9e90
-
-/*
- * Hameg HO820 and HO870 interface (using VID 0x0403)
- */
-#define        HAMEG_HO820_PID         0xed74
-#define        HAMEG_HO870_PID         0xed71
 
 /*
  *   BmRequestType:  1100 0000b
@@ -1206,7 +270,7 @@ typedef enum {
  *   BmRequestType:  0100 0000b
  *   bRequest:       FTDI_SIO_SET_FLOW_CTRL
  *   wValue:         Xoff/Xon
- *   wIndex:         Protocol/Port - hIndex is protocl / lIndex is port
+ *   wIndex:         Protocol/Port - hIndex is protocol / lIndex is port
  *   wLength:        0
  *   Data:           None
  *
@@ -1490,4 +554,3 @@ typedef enum {
  * B2..7        Length of message - (not including Byte 0)
  *
  */
-
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
new file mode 100644
index 000000000000..75482cbc3998
--- /dev/null
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -0,0 +1,1026 @@
+/*
+ * vendor/product IDs (VID/PID) of devices using FTDI USB serial converters.
+ * Please keep numerically sorted within individual areas, thanks!
+ *
+ * Philipp Gühring - pg@futureware.at - added the Device ID of the USB relais
+ * from Rudolf Gugler
+ *
+ */
+
+
+/**********************************/
+/***** devices using FTDI VID *****/
+/**********************************/
+
+
+#define FTDI_VID        0x0403  /* Vendor Id */
+
+
+/*** "original" FTDI device PIDs ***/
+
+#define FTDI_8U232AM_PID 0x6001 /* Similar device to SIO above */
+#define FTDI_8U232AM_ALT_PID 0x6006 /* FTDI's alternate PID for above */
+#define FTDI_8U2232C_PID 0x6010 /* Dual channel device */
+#define FTDI_4232H_PID 0x6011 /* Quad channel hi-speed device */
+#define FTDI_SIO_PID    0x8372  /* Product Id SIO application of 8U100AX */
+#define FTDI_232RL_PID  0xFBFA  /* Product ID for FT232RL */
+
+
+/*** third-party PIDs (using FTDI_VID) ***/
+
+/*
+ * Marvell OpenRD Base, Client
+ * http://www.open-rd.org
+ * OpenRD Base, Client use VID 0x0403
+ */
+#define MARVELL_OPENRD_PID      0x9e90
+
+/* www.candapter.com Ewert Energy Systems CANdapter device */
+#define FTDI_CANDAPTER_PID 0x9F80 /* Product Id */
+
+#define FTDI_NXTCAM_PID         0xABB8 /* NXTCam for Mindstorms NXT */
+
+/* OOCDlink by Joern Kaipf <joernk@web.de>
+ * (http://www.joernonline.de/dw/doku.php?id=start&idx=projects:oocdlink) */
+#define FTDI_OOCDLINK_PID       0xbaf8  /* Amontec JTAGkey */
+
+/* Luminary Micro Stellaris Boards, VID = FTDI_VID */
+/* FTDI 2332C Dual channel device, side A=245 FIFO (JTAG), Side B=RS232 UART */
+#define LMI_LM3S_DEVEL_BOARD_PID        0xbcd8
+#define LMI_LM3S_EVAL_BOARD_PID         0xbcd9
+
+#define FTDI_TURTELIZER_PID     0xBDC8 /* JTAG/RS-232 adapter by egnite GmbH */
+
+/* OpenDCC (www.opendcc.de) product id */
+#define FTDI_OPENDCC_PID        0xBFD8
+#define FTDI_OPENDCC_SNIFFER_PID        0xBFD9
+#define FTDI_OPENDCC_THROTTLE_PID       0xBFDA
+#define FTDI_OPENDCC_GATEWAY_PID        0xBFDB
+
+/*
+ * RR-CirKits LocoBuffer USB (http://www.rr-cirkits.com)
+ */
+#define FTDI_RRCIRKITS_LOCOBUFFER_PID   0xc7d0  /* LocoBuffer USB */
+
+/* DMX4ALL DMX Interfaces */
+#define FTDI_DMX4ALL 0xC850
+
+/*
+ * ASK.fr devices
+ */
+#define FTDI_ASK_RDR400_PID     0xC991  /* ASK RDR 400 series card reader */
+
+/* www.starting-point-systems.com µChameleon device */
+#define FTDI_MICRO_CHAMELEON_PID        0xCAA0  /* Product Id */
+
+/*
+ * Tactrix OpenPort (ECU) devices.
+ * OpenPort 1.3M submitted by Donour Sizemore.
+ * OpenPort 1.3S and 1.3U submitted by Ian Abbott.
+ */
+#define FTDI_TACTRIX_OPENPORT_13M_PID   0xCC48  /* OpenPort 1.3 Mitsubishi */
+#define FTDI_TACTRIX_OPENPORT_13S_PID   0xCC49  /* OpenPort 1.3 Subaru */
+#define FTDI_TACTRIX_OPENPORT_13U_PID   0xCC4A  /* OpenPort 1.3 Universal */
+
+/* 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
+
+/* iPlus device */
+#define FTDI_IPLUS_PID 0xD070 /* Product Id */
+#define FTDI_IPLUS2_PID 0xD071 /* Product Id */
+
+/*
+ * Gamma Scout (http://gamma-scout.com/). Submitted by rsc@runtux.com.
+ */
+#define FTDI_GAMMA_SCOUT_PID            0xD678  /* Gamma Scout online */
+
+/* Propox devices */
+#define FTDI_PROPOX_JTAGCABLEII_PID     0xD738
+
+/*
+ * Xsens Technologies BV products (http://www.xsens.com).
+ */
+#define XSENS_CONVERTER_0_PID   0xD388
+#define XSENS_CONVERTER_1_PID   0xD389
+#define XSENS_CONVERTER_2_PID   0xD38A
+#define XSENS_CONVERTER_3_PID   0xD38B
+#define XSENS_CONVERTER_4_PID   0xD38C
+#define XSENS_CONVERTER_5_PID   0xD38D
+#define XSENS_CONVERTER_6_PID   0xD38E
+#define XSENS_CONVERTER_7_PID   0xD38F
+
+/*
+ * NDI (www.ndigital.com) product ids
+ */
+#define FTDI_NDI_HUC_PID                0xDA70  /* NDI Host USB Converter */
+#define FTDI_NDI_SPECTRA_SCU_PID        0xDA71  /* NDI Spectra SCU */
+#define FTDI_NDI_FUTURE_2_PID           0xDA72  /* NDI future device #2 */
+#define FTDI_NDI_FUTURE_3_PID           0xDA73  /* NDI future device #3 */
+#define FTDI_NDI_AURORA_SCU_PID         0xDA74  /* NDI Aurora SCU */
+
+/*
+ * Westrex International devices submitted by Cory Lee
+ */
+#define FTDI_WESTREX_MODEL_777_PID      0xDC00  /* Model 777 */
+#define FTDI_WESTREX_MODEL_8900F_PID    0xDC01  /* Model 8900F */
+
+/*
+ * ACG Identification Technologies GmbH products (http://www.acg.de/).
+ * Submitted by anton -at- goto10 -dot- org.
+ */
+#define FTDI_ACG_HFDUAL_PID             0xDD20  /* HF Dual ISO Reader (RFID) */
+
+/*
+ * Definitions for Artemis astronomical USB based cameras
+ * Check it at http://www.artemisccd.co.uk/
+ */
+#define FTDI_ARTEMIS_PID        0xDF28  /* All Artemis Cameras */
+
+/*
+ * Definitions for ATIK Instruments astronomical USB based cameras
+ * Check it at http://www.atik-instruments.com/
+ */
+#define FTDI_ATIK_ATK16_PID     0xDF30  /* ATIK ATK-16 Grayscale Camera */
+#define FTDI_ATIK_ATK16C_PID    0xDF32  /* ATIK ATK-16C Colour Camera */
+#define FTDI_ATIK_ATK16HR_PID   0xDF31  /* ATIK ATK-16HR Grayscale Camera */
+#define FTDI_ATIK_ATK16HRC_PID  0xDF33  /* ATIK ATK-16HRC Colour Camera */
+#define FTDI_ATIK_ATK16IC_PID   0xDF35  /* ATIK ATK-16IC Grayscale Camera */
+
+/*
+ * Yost Engineering, Inc. products (www.yostengineering.com).
+ * PID 0xE050 submitted by Aaron Prose.
+ */
+#define FTDI_YEI_SERVOCENTER31_PID      0xE050  /* YEI ServoCenter3.1 USB */
+
+/*
+ * ELV USB devices submitted by Christian Abt of ELV (www.elv.de).
+ * All of these devices use FTDI's vendor ID (0x0403).
+ * Further IDs taken from ELV Windows .inf file.
+ *
+ * The previously included PID for the UO 100 module was incorrect.
+ * In fact, that PID was for ELV's UR 100 USB-RS232 converter (0xFB58).
+ *
+ * Armin Laeuger originally sent the PID for the UM 100 module.
+ */
+#define FTDI_ELV_USR_PID        0xE000  /* ELV Universal-Sound-Recorder */
+#define FTDI_ELV_MSM1_PID       0xE001  /* ELV Mini-Sound-Modul */
+#define FTDI_ELV_KL100_PID      0xE002  /* ELV Kfz-Leistungsmesser KL 100 */
+#define FTDI_ELV_WS550_PID      0xE004  /* WS 550 */
+#define FTDI_ELV_EC3000_PID     0xE006  /* ENERGY CONTROL 3000 USB */
+#define FTDI_ELV_WS888_PID      0xE008  /* WS 888 */
+#define FTDI_ELV_TWS550_PID     0xE009  /* Technoline WS 550 */
+#define FTDI_ELV_FEM_PID        0xE00A  /* Funk Energie Monitor */
+#define FTDI_ELV_FHZ1300PC_PID  0xE0E8  /* FHZ 1300 PC */
+#define FTDI_ELV_WS500_PID      0xE0E9  /* PC-Wetterstation (WS 500) */
+#define FTDI_ELV_HS485_PID      0xE0EA  /* USB to RS-485 adapter */
+#define FTDI_ELV_UMS100_PID     0xE0EB  /* ELV USB Master-Slave Schaltsteckdose UMS 100 */
+#define FTDI_ELV_TFD128_PID     0xE0EC  /* ELV Temperatur-Feuchte-Datenlogger TFD 128 */
+#define FTDI_ELV_FM3RX_PID      0xE0ED  /* ELV Messwertuebertragung FM3 RX */
+#define FTDI_ELV_WS777_PID      0xE0EE  /* Conrad WS 777 */
+#define FTDI_ELV_EM1010PC_PID   0xE0EF  /* Energy monitor EM 1010 PC */
+#define FTDI_ELV_CSI8_PID       0xE0F0  /* Computer-Schalt-Interface (CSI 8) */
+#define FTDI_ELV_EM1000DL_PID   0xE0F1  /* PC-Datenlogger fuer Energiemonitor (EM 1000 DL) */
+#define FTDI_ELV_PCK100_PID     0xE0F2  /* PC-Kabeltester (PCK 100) */
+#define FTDI_ELV_RFP500_PID     0xE0F3  /* HF-Leistungsmesser (RFP 500) */
+#define FTDI_ELV_FS20SIG_PID    0xE0F4  /* Signalgeber (FS 20 SIG) */
+#define FTDI_ELV_UTP8_PID       0xE0F5  /* ELV UTP 8 */
+#define FTDI_ELV_WS300PC_PID    0xE0F6  /* PC-Wetterstation (WS 300 PC) */
+#define FTDI_ELV_WS444PC_PID    0xE0F7  /* Conrad WS 444 PC */
+#define FTDI_PHI_FISCO_PID      0xE40B  /* PHI Fisco USB to Serial cable */
+#define FTDI_ELV_UAD8_PID       0xF068  /* USB-AD-Wandler (UAD 8) */
+#define FTDI_ELV_UDA7_PID       0xF069  /* USB-DA-Wandler (UDA 7) */
+#define FTDI_ELV_USI2_PID       0xF06A  /* USB-Schrittmotoren-Interface (USI 2) */
+#define FTDI_ELV_T1100_PID      0xF06B  /* Thermometer (T 1100) */
+#define FTDI_ELV_PCD200_PID     0xF06C  /* PC-Datenlogger (PCD 200) */
+#define FTDI_ELV_ULA200_PID     0xF06D  /* USB-LCD-Ansteuerung (ULA 200) */
+#define FTDI_ELV_ALC8500_PID    0xF06E  /* ALC 8500 Expert */
+#define FTDI_ELV_FHZ1000PC_PID  0xF06F  /* FHZ 1000 PC */
+#define FTDI_ELV_UR100_PID      0xFB58  /* USB-RS232-Umsetzer (UR 100) */
+#define FTDI_ELV_UM100_PID      0xFB5A  /* USB-Modul UM 100 */
+#define FTDI_ELV_UO100_PID      0xFB5B  /* USB-Modul UO 100 */
+/* Additional ELV PIDs that default to using the FTDI D2XX drivers on
+ * MS Windows, rather than the FTDI Virtual Com Port drivers.
+ * Maybe these will be easier to use with the libftdi/libusb user-space
+ * drivers, or possibly the Comedi drivers in some cases. */
+#define FTDI_ELV_CLI7000_PID    0xFB59  /* Computer-Light-Interface (CLI 7000) */
+#define FTDI_ELV_PPS7330_PID    0xFB5C  /* Processor-Power-Supply (PPS 7330) */
+#define FTDI_ELV_TFM100_PID     0xFB5D  /* Temperatur-Feuchte-Messgeraet (TFM 100) */
+#define FTDI_ELV_UDF77_PID      0xFB5E  /* USB DCF Funkuhr (UDF 77) */
+#define FTDI_ELV_UIO88_PID      0xFB5F  /* USB-I/O Interface (UIO 88) */
+
+/*
+ * EVER Eco Pro UPS (http://www.ever.com.pl/)
+ */
+
+#define EVER_ECO_PRO_CDS        0xe520  /* RS-232 converter */
+
+/*
+ * Active Robots product ids.
+ */
+#define FTDI_ACTIVE_ROBOTS_PID  0xE548  /* USB comms board */
+
+/* Pyramid Computer GmbH */
+#define FTDI_PYRAMID_PID        0xE6C8  /* Pyramid Appliance Display */
+
+/* www.elsterelectricity.com Elster Unicom III Optical Probe */
+#define FTDI_ELSTER_UNICOM_PID          0xE700 /* Product Id */
+
+/*
+ * Gude Analog- und Digitalsysteme GmbH
+ */
+#define FTDI_GUDEADS_E808_PID    0xE808
+#define FTDI_GUDEADS_E809_PID    0xE809
+#define FTDI_GUDEADS_E80A_PID    0xE80A
+#define FTDI_GUDEADS_E80B_PID    0xE80B
+#define FTDI_GUDEADS_E80C_PID    0xE80C
+#define FTDI_GUDEADS_E80D_PID    0xE80D
+#define FTDI_GUDEADS_E80E_PID    0xE80E
+#define FTDI_GUDEADS_E80F_PID    0xE80F
+#define FTDI_GUDEADS_E888_PID    0xE888  /* Expert ISDN Control USB */
+#define FTDI_GUDEADS_E889_PID    0xE889  /* USB RS-232 OptoBridge */
+#define FTDI_GUDEADS_E88A_PID    0xE88A
+#define FTDI_GUDEADS_E88B_PID    0xE88B
+#define FTDI_GUDEADS_E88C_PID    0xE88C
+#define FTDI_GUDEADS_E88D_PID    0xE88D
+#define FTDI_GUDEADS_E88E_PID    0xE88E
+#define FTDI_GUDEADS_E88F_PID    0xE88F
+
+/*
+ * Eclo (http://www.eclo.pt/) product IDs.
+ * PID 0xEA90 submitted by Martin Grill.
+ */
+#define FTDI_ECLO_COM_1WIRE_PID 0xEA90  /* COM to 1-Wire USB adaptor */
+
+/* TNC-X USB-to-packet-radio adapter, versions prior to 3.0 (DLP module) */
+#define FTDI_TNC_X_PID          0xEBE0
+
+/*
+ * Teratronik product ids.
+ * Submitted by O. Wölfelschneider.
+ */
+#define FTDI_TERATRONIK_VCP_PID  0xEC88 /* Teratronik device (preferring VCP driver on windows) */
+#define FTDI_TERATRONIK_D2XX_PID 0xEC89 /* Teratronik device (preferring D2XX driver on windows) */
+
+/* Rig Expert Ukraine devices */
+#define FTDI_REU_TINY_PID               0xED22  /* RigExpert Tiny */
+
+/*
+ * Hameg HO820 and HO870 interface (using VID 0x0403)
+ */
+#define        HAMEG_HO820_PID         0xed74
+#define        HAMEG_HO870_PID         0xed71
+
+/*
+ *  MaxStream devices   www.maxstream.net
+ */
+#define FTDI_MAXSTREAM_PID      0xEE18  /* Xbee PKG-U Module */
+
+/*
+ * microHAM product IDs (http://www.microham.com).
+ * Submitted by Justin Burket (KL1RL) <zorton@jtan.com>
+ * and Mike Studer (K6EEP) <k6eep@hamsoftware.org>.
+ * Ian Abbott <abbotti@mev.co.uk> added a few more from the driver INF file.
+ */
+#define FTDI_MHAM_KW_PID 0xEEE8         /* USB-KW interface */
+#define FTDI_MHAM_YS_PID 0xEEE9         /* USB-YS interface */
+#define FTDI_MHAM_Y6_PID 0xEEEA         /* USB-Y6 interface */
+#define FTDI_MHAM_Y8_PID 0xEEEB         /* USB-Y8 interface */
+#define FTDI_MHAM_IC_PID 0xEEEC         /* USB-IC interface */
+#define FTDI_MHAM_DB9_PID 0xEEED        /* USB-DB9 interface */
+#define FTDI_MHAM_RS232_PID 0xEEEE      /* USB-RS232 interface */
+#define FTDI_MHAM_Y9_PID 0xEEEF         /* USB-Y9 interface */
+
+/* Domintell products  http://www.domintell.com */
+#define FTDI_DOMINTELL_DGQG_PID 0xEF50  /* Master */
+#define FTDI_DOMINTELL_DUSB_PID 0xEF51  /* DUSB01 module */
+
+/*
+ * The following are the values for the Perle Systems
+ * UltraPort USB serial converters
+ */
+#define FTDI_PERLE_ULTRAPORT_PID 0xF0C0 /* Perle UltraPort Product Id */
+
+/* Sprog II (Andrew Crosland's SprogII DCC interface) */
+#define FTDI_SPROG_II           0xF0C8
+
+/* an infrared receiver for user access control with IR tags */
+#define FTDI_PIEGROUP_PID       0xF208  /* Product Id */
+
+/* ACT Solutions HomePro ZWave interface
+   (http://www.act-solutions.com/HomePro.htm) */
+#define FTDI_ACTZWAVE_PID       0xF2D0
+
+/*
+ * 4N-GALAXY.DE PIDs for CAN-USB, USB-RS232, USB-RS422, USB-RS485,
+ * USB-TTY aktiv, USB-TTY passiv.  Some PIDs are used by several devices
+ * and I'm not entirely sure which are used by which.
+ */
+#define FTDI_4N_GALAXY_DE_1_PID 0xF3C0
+#define FTDI_4N_GALAXY_DE_2_PID 0xF3C1
+
+/*
+ * Linx Technologies product ids
+ */
+#define LINX_SDMUSBQSS_PID      0xF448  /* Linx SDM-USB-QS-S */
+#define LINX_MASTERDEVEL2_PID   0xF449  /* Linx Master Development 2.0 */
+#define LINX_FUTURE_0_PID   0xF44A      /* Linx future device */
+#define LINX_FUTURE_1_PID   0xF44B      /* Linx future device */
+#define LINX_FUTURE_2_PID   0xF44C      /* Linx future device */
+
+/*
+ * Oceanic product ids
+ */
+#define FTDI_OCEANIC_PID        0xF460  /* Oceanic dive instrument */
+
+/*
+ * SUUNTO product ids
+ */
+#define FTDI_SUUNTO_SPORTS_PID  0xF680  /* Suunto Sports instrument */
+
+/* USB-UIRT - An infrared receiver and transmitter using the 8U232AM chip */
+/* http://home.earthlink.net/~jrhees/USBUIRT/index.htm */
+#define FTDI_USB_UIRT_PID       0xF850  /* Product Id */
+
+/* CCS Inc. ICDU/ICDU40 product ID -
+ * the FT232BM is used in an in-circuit-debugger unit for PIC16's/PIC18's */
+#define FTDI_CCSICDU20_0_PID    0xF9D0
+#define FTDI_CCSICDU40_1_PID    0xF9D1
+#define FTDI_CCSMACHX_2_PID     0xF9D2
+#define FTDI_CCSLOAD_N_GO_3_PID 0xF9D3
+#define FTDI_CCSICDU64_4_PID    0xF9D4
+#define FTDI_CCSPRIME8_5_PID    0xF9D5
+
+/*
+ * The following are the values for the Matrix Orbital LCD displays,
+ * which are the FT232BM ( similar to the 8U232AM )
+ */
+#define FTDI_MTXORB_0_PID      0xFA00  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_1_PID      0xFA01  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_2_PID      0xFA02  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_3_PID      0xFA03  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_4_PID      0xFA04  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_5_PID      0xFA05  /* Matrix Orbital Product Id */
+#define FTDI_MTXORB_6_PID      0xFA06  /* Matrix Orbital Product Id */
+
+/*
+ * Home Electronics (www.home-electro.com) USB gadgets
+ */
+#define FTDI_HE_TIRA1_PID       0xFA78  /* Tira-1 IR transceiver */
+
+/* Inside Accesso contactless reader (http://www.insidefr.com) */
+#define INSIDE_ACCESSO          0xFAD0
+
+/*
+ * ThorLabs USB motor drivers
+ */
+#define FTDI_THORLABS_PID               0xfaf0 /* ThorLabs USB motor drivers */
+
+/*
+ * Protego product ids
+ */
+#define PROTEGO_SPECIAL_1       0xFC70  /* special/unknown device */
+#define PROTEGO_R2X0            0xFC71  /* R200-USB TRNG unit (R210, R220, and R230) */
+#define PROTEGO_SPECIAL_3       0xFC72  /* special/unknown device */
+#define PROTEGO_SPECIAL_4       0xFC73  /* special/unknown device */
+
+/*
+ * DSS-20 Sync Station for Sony Ericsson P800
+ */
+#define FTDI_DSS20_PID          0xFC82
+
+/* www.irtrans.de device */
+#define FTDI_IRTRANS_PID 0xFC60 /* Product Id */
+
+/*
+ * RM Michaelides CANview USB (http://www.rmcan.com) (FTDI_VID)
+ * CAN fieldbus interface adapter, added by port GmbH www.port.de)
+ * Ian Abbott changed the macro names for consistency.
+ */
+#define FTDI_RM_CANVIEW_PID     0xfd60  /* Product Id */
+/* www.thoughttechnology.com/ TT-USB provide with procomp use ftdi_sio */
+#define FTDI_TTUSB_PID 0xFF20 /* Product Id */
+
+#define FTDI_USBX_707_PID 0xF857        /* ADSTech IR Blaster USBX-707 (FTDI_VID) */
+
+#define FTDI_RELAIS_PID 0xFA10  /* Relais device from Rudolf Gugler */
+
+/*
+ * PCDJ use ftdi based dj-controllers. The following PID is
+ * for their DAC-2 device http://www.pcdjhardware.com/DAC2.asp
+ * (the VID is the standard ftdi vid (FTDI_VID), PID sent by Wouter Paesen)
+ */
+#define FTDI_PCDJ_DAC2_PID 0xFA88
+
+#define FTDI_R2000KU_TRUE_RNG   0xFB80  /* R2000KU TRUE RNG (FTDI_VID) */
+
+/*
+ * DIEBOLD BCS SE923 (FTDI_VID)
+ */
+#define DIEBOLD_BCS_SE923_PID   0xfb99
+
+/* www.crystalfontz.com devices
+ * - thanx for providing free devices for evaluation !
+ * they use the ftdi chipset for the USB interface
+ * and the vendor id is the same
+ */
+#define FTDI_XF_632_PID 0xFC08  /* 632: 16x2 Character Display */
+#define FTDI_XF_634_PID 0xFC09  /* 634: 20x4 Character Display */
+#define FTDI_XF_547_PID 0xFC0A  /* 547: Two line Display */
+#define FTDI_XF_633_PID 0xFC0B  /* 633: 16x2 Character Display with Keys */
+#define FTDI_XF_631_PID 0xFC0C  /* 631: 20x2 Character Display */
+#define FTDI_XF_635_PID 0xFC0D  /* 635: 20x4 Character Display */
+#define FTDI_XF_640_PID 0xFC0E  /* 640: Two line Display */
+#define FTDI_XF_642_PID 0xFC0F  /* 642: Two line Display */
+
+/*
+ * Video Networks Limited / Homechoice in the UK use an ftdi-based device
+ * for their 1Mb broadband internet service.  The following PID is exhibited
+ * by the usb device supplied (the VID is the standard ftdi vid (FTDI_VID)
+ */
+#define FTDI_VNHCPCUSB_D_PID 0xfe38 /* Product Id */
+
+/* AlphaMicro Components AMC-232USB01 device (FTDI_VID) */
+#define FTDI_AMC232_PID 0xFF00 /* Product Id */
+
+/*
+ * IBS elektronik product ids (FTDI_VID)
+ * Submitted by Thomas Schleusener
+ */
+#define FTDI_IBS_US485_PID      0xff38  /* IBS US485 (USB<-->RS422/485 interface) */
+#define FTDI_IBS_PICPRO_PID     0xff39  /* IBS PIC-Programmer */
+#define FTDI_IBS_PCMCIA_PID     0xff3a  /* IBS Card reader for PCMCIA SRAM-cards */
+#define FTDI_IBS_PK1_PID        0xff3b  /* IBS PK1 - Particel counter */
+#define FTDI_IBS_RS232MON_PID   0xff3c  /* IBS RS232 - Monitor */
+#define FTDI_IBS_APP70_PID      0xff3d  /* APP 70 (dust monitoring system) */
+#define FTDI_IBS_PEDO_PID       0xff3e  /* IBS PEDO-Modem (RF modem 868.35 MHz) */
+#define FTDI_IBS_PROD_PID       0xff3f  /* future device */
+/* www.canusb.com Lawicel CANUSB device (FTDI_VID) */
+#define FTDI_CANUSB_PID 0xFFA8 /* Product Id */
+
+
+
+/********************************/
+/** third-party VID/PID combos **/
+/********************************/
+
+
+
+/*
+ * Atmel STK541
+ */
+#define ATMEL_VID               0x03eb /* Vendor ID */
+#define STK541_PID              0x2109 /* Zigbee Controller */
+
+/*
+ * Blackfin gnICE JTAG
+ * http://docs.blackfin.uclinux.org/doku.php?id=hw:jtag:gnice
+ */
+#define ADI_VID                 0x0456
+#define ADI_GNICE_PID           0xF000
+#define ADI_GNICEPLUS_PID       0xF001
+
+/*
+ * RATOC REX-USB60F
+ */
+#define RATOC_VENDOR_ID         0x0584
+#define RATOC_PRODUCT_ID_USB60F 0xb020
+
+/*
+ * Contec products (http://www.contec.com)
+ * Submitted by Daniel Sangorrin
+ */
+#define CONTEC_VID              0x06CE  /* Vendor ID */
+#define CONTEC_COM1USBH_PID     0x8311  /* COM-1(USB)H */
+
+/*
+ * Contec products (http://www.contec.com)
+ * Submitted by Daniel Sangorrin
+ */
+#define CONTEC_VID              0x06CE  /* Vendor ID */
+#define CONTEC_COM1USBH_PID     0x8311  /* COM-1(USB)H */
+
+/*
+ * Definitions for B&B Electronics products.
+ */
+#define BANDB_VID               0x0856  /* B&B Electronics Vendor ID */
+#define BANDB_USOTL4_PID        0xAC01  /* USOTL4 Isolated RS-485 Converter */
+#define BANDB_USTL4_PID         0xAC02  /* USTL4 RS-485 Converter */
+#define BANDB_USO9ML2_PID       0xAC03  /* USO9ML2 Isolated RS-232 Converter */
+#define BANDB_USOPTL4_PID       0xAC11
+#define BANDB_USPTL4_PID        0xAC12
+#define BANDB_USO9ML2DR_2_PID   0xAC16
+#define BANDB_USO9ML2DR_PID     0xAC17
+#define BANDB_USOPTL4DR2_PID    0xAC18  /* USOPTL4R-2 2-port Isolated RS-232 Converter */
+#define BANDB_USOPTL4DR_PID     0xAC19
+#define BANDB_485USB9F_2W_PID   0xAC25
+#define BANDB_485USB9F_4W_PID   0xAC26
+#define BANDB_232USB9M_PID      0xAC27
+#define BANDB_485USBTB_2W_PID   0xAC33
+#define BANDB_485USBTB_4W_PID   0xAC34
+#define BANDB_TTL5USB9M_PID     0xAC49
+#define BANDB_TTL3USB9M_PID     0xAC50
+#define BANDB_ZZ_PROG1_USB_PID  0xBA02
+
+/*
+ * Intrepid Control Systems (http://www.intrepidcs.com/) ValueCAN and NeoVI
+ */
+#define INTREPID_VID            0x093C
+#define INTREPID_VALUECAN_PID   0x0601
+#define INTREPID_NEOVI_PID      0x0701
+
+/*
+ * Definitions for ID TECH (www.idt-net.com) devices
+ */
+#define IDTECH_VID              0x0ACD  /* ID TECH Vendor ID */
+#define IDTECH_IDT1221U_PID     0x0300  /* IDT1221U USB to RS-232 adapter */
+
+/*
+ * Definitions for Omnidirectional Control Technology, Inc. devices
+ */
+#define OCT_VID                 0x0B39  /* OCT vendor ID */
+/* Note: OCT US101 is also rebadged as Dick Smith Electronics (NZ) XH6381 */
+/* Also rebadged as Dick Smith Electronics (Aus) XH6451 */
+/* Also rebadged as SIIG Inc. model US2308 hardware version 1 */
+#define OCT_US101_PID           0x0421  /* OCT US101 USB to RS-232 */
+
+/*
+ * Icom ID-1 digital transceiver
+ */
+
+#define ICOM_ID1_VID            0x0C26
+#define ICOM_ID1_PID            0x0004
+
+/*
+ * GN Otometrics (http://www.otometrics.com)
+ * Submitted by Ville Sundberg.
+ */
+#define GN_OTOMETRICS_VID       0x0c33  /* Vendor ID */
+#define AURICAL_USB_PID         0x0010  /* Aurical USB Audiometer */
+
+/*
+ * The following are the values for the Sealevel SeaLINK+ adapters.
+ * (Original list sent by Tuan Hoang.  Ian Abbott renamed the macros and
+ * removed some PIDs that don't seem to match any existing products.)
+ */
+#define SEALEVEL_VID            0x0c52  /* Sealevel Vendor ID */
+#define SEALEVEL_2101_PID       0x2101  /* SeaLINK+232 (2101/2105) */
+#define SEALEVEL_2102_PID       0x2102  /* SeaLINK+485 (2102) */
+#define SEALEVEL_2103_PID       0x2103  /* SeaLINK+232I (2103) */
+#define SEALEVEL_2104_PID       0x2104  /* SeaLINK+485I (2104) */
+#define SEALEVEL_2106_PID       0x9020  /* SeaLINK+422 (2106) */
+#define SEALEVEL_2201_1_PID     0x2211  /* SeaPORT+2/232 (2201) Port 1 */
+#define SEALEVEL_2201_2_PID     0x2221  /* SeaPORT+2/232 (2201) Port 2 */
+#define SEALEVEL_2202_1_PID     0x2212  /* SeaPORT+2/485 (2202) Port 1 */
+#define SEALEVEL_2202_2_PID     0x2222  /* SeaPORT+2/485 (2202) Port 2 */
+#define SEALEVEL_2203_1_PID     0x2213  /* SeaPORT+2 (2203) Port 1 */
+#define SEALEVEL_2203_2_PID     0x2223  /* SeaPORT+2 (2203) Port 2 */
+#define SEALEVEL_2401_1_PID     0x2411  /* SeaPORT+4/232 (2401) Port 1 */
+#define SEALEVEL_2401_2_PID     0x2421  /* SeaPORT+4/232 (2401) Port 2 */
+#define SEALEVEL_2401_3_PID     0x2431  /* SeaPORT+4/232 (2401) Port 3 */
+#define SEALEVEL_2401_4_PID     0x2441  /* SeaPORT+4/232 (2401) Port 4 */
+#define SEALEVEL_2402_1_PID     0x2412  /* SeaPORT+4/485 (2402) Port 1 */
+#define SEALEVEL_2402_2_PID     0x2422  /* SeaPORT+4/485 (2402) Port 2 */
+#define SEALEVEL_2402_3_PID     0x2432  /* SeaPORT+4/485 (2402) Port 3 */
+#define SEALEVEL_2402_4_PID     0x2442  /* SeaPORT+4/485 (2402) Port 4 */
+#define SEALEVEL_2403_1_PID     0x2413  /* SeaPORT+4 (2403) Port 1 */
+#define SEALEVEL_2403_2_PID     0x2423  /* SeaPORT+4 (2403) Port 2 */
+#define SEALEVEL_2403_3_PID     0x2433  /* SeaPORT+4 (2403) Port 3 */
+#define SEALEVEL_2403_4_PID     0x2443  /* SeaPORT+4 (2403) Port 4 */
+#define SEALEVEL_2801_1_PID     0X2811  /* SeaLINK+8/232 (2801) Port 1 */
+#define SEALEVEL_2801_2_PID     0X2821  /* SeaLINK+8/232 (2801) Port 2 */
+#define SEALEVEL_2801_3_PID     0X2831  /* SeaLINK+8/232 (2801) Port 3 */
+#define SEALEVEL_2801_4_PID     0X2841  /* SeaLINK+8/232 (2801) Port 4 */
+#define SEALEVEL_2801_5_PID     0X2851  /* SeaLINK+8/232 (2801) Port 5 */
+#define SEALEVEL_2801_6_PID     0X2861  /* SeaLINK+8/232 (2801) Port 6 */
+#define SEALEVEL_2801_7_PID     0X2871  /* SeaLINK+8/232 (2801) Port 7 */
+#define SEALEVEL_2801_8_PID     0X2881  /* SeaLINK+8/232 (2801) Port 8 */
+#define SEALEVEL_2802_1_PID     0X2812  /* SeaLINK+8/485 (2802) Port 1 */
+#define SEALEVEL_2802_2_PID     0X2822  /* SeaLINK+8/485 (2802) Port 2 */
+#define SEALEVEL_2802_3_PID     0X2832  /* SeaLINK+8/485 (2802) Port 3 */
+#define SEALEVEL_2802_4_PID     0X2842  /* SeaLINK+8/485 (2802) Port 4 */
+#define SEALEVEL_2802_5_PID     0X2852  /* SeaLINK+8/485 (2802) Port 5 */
+#define SEALEVEL_2802_6_PID     0X2862  /* SeaLINK+8/485 (2802) Port 6 */
+#define SEALEVEL_2802_7_PID     0X2872  /* SeaLINK+8/485 (2802) Port 7 */
+#define SEALEVEL_2802_8_PID     0X2882  /* SeaLINK+8/485 (2802) Port 8 */
+#define SEALEVEL_2803_1_PID     0X2813  /* SeaLINK+8 (2803) Port 1 */
+#define SEALEVEL_2803_2_PID     0X2823  /* SeaLINK+8 (2803) Port 2 */
+#define SEALEVEL_2803_3_PID     0X2833  /* SeaLINK+8 (2803) Port 3 */
+#define SEALEVEL_2803_4_PID     0X2843  /* SeaLINK+8 (2803) Port 4 */
+#define SEALEVEL_2803_5_PID     0X2853  /* SeaLINK+8 (2803) Port 5 */
+#define SEALEVEL_2803_6_PID     0X2863  /* SeaLINK+8 (2803) Port 6 */
+#define SEALEVEL_2803_7_PID     0X2873  /* SeaLINK+8 (2803) Port 7 */
+#define SEALEVEL_2803_8_PID     0X2883  /* SeaLINK+8 (2803) Port 8 */
+
+/*
+ * JETI SPECTROMETER SPECBOS 1201
+ * http://www.jeti.com/products/sys/scb/scb1201.php
+ */
+#define JETI_VID                0x0c6c
+#define JETI_SPC1201_PID        0x04b2
+
+/*
+ * FTDI USB UART chips used in construction projects from the
+ * Elektor Electronics magazine (http://elektor-electronics.co.uk)
+ */
+#define ELEKTOR_VID             0x0C7D
+#define ELEKTOR_FT323R_PID      0x0005  /* RFID-Reader, issue 09-2006 */
+
+/*
+ * Posiflex inc retail equipment (http://www.posiflex.com.tw)
+ */
+#define POSIFLEX_VID            0x0d3a  /* Vendor ID */
+#define POSIFLEX_PP7000_PID     0x0300  /* PP-7000II thermal printer */
+
+/*
+ * The following are the values for two KOBIL chipcard terminals.
+ */
+#define KOBIL_VID               0x0d46  /* KOBIL Vendor ID */
+#define KOBIL_CONV_B1_PID       0x2020  /* KOBIL Konverter for B1 */
+#define KOBIL_CONV_KAAN_PID     0x2021  /* KOBIL_Konverter for KAAN */
+
+#define FTDI_NF_RIC_VID 0x0DCD  /* Vendor Id */
+#define FTDI_NF_RIC_PID 0x0001  /* Product Id */
+
+/*
+ * Falcom Wireless Communications GmbH
+ */
+#define FALCOM_VID              0x0F94  /* Vendor Id */
+#define FALCOM_TWIST_PID        0x0001  /* Falcom Twist USB GPRS modem */
+#define FALCOM_SAMBA_PID        0x0005  /* Falcom Samba USB GPRS modem */
+
+/* Larsen and Brusgaard AltiTrack/USBtrack */
+#define LARSENBRUSGAARD_VID             0x0FD8
+#define LB_ALTITRACK_PID                0x0001
+
+/*
+ * TTi (Thurlby Thandar Instruments)
+ */
+#define TTI_VID                 0x103E  /* Vendor Id */
+#define TTI_QL355P_PID          0x03E8  /* TTi QL355P power supply */
+
+/* Interbiometrics USB I/O Board */
+/* Developed for Interbiometrics by Rudolf Gugler */
+#define INTERBIOMETRICS_VID              0x1209
+#define INTERBIOMETRICS_IOBOARD_PID      0x1002
+#define INTERBIOMETRICS_MINI_IOBOARD_PID 0x1006
+
+/*
+ * Testo products (http://www.testo.com/)
+ * Submitted by Colin Leroy
+ */
+#define TESTO_VID                       0x128D
+#define TESTO_USB_INTERFACE_PID         0x0001
+
+/*
+ * Mobility Electronics products.
+ */
+#define MOBILITY_VID                    0x1342
+#define MOBILITY_USB_SERIAL_PID         0x0202  /* EasiDock USB 200 serial */
+
+/*
+ * FIC / OpenMoko, Inc. http://wiki.openmoko.org/wiki/Neo1973_Debug_Board_v3
+ * Submitted by Harald Welte <laforge@openmoko.org>
+ */
+#define FIC_VID                 0x1457
+#define FIC_NEO1973_DEBUG_PID   0x5118
+
+/* Olimex */
+#define OLIMEX_VID                      0x15BA
+#define OLIMEX_ARM_USB_OCD_PID          0x0003
+
+/*
+ * Telldus Technologies
+ */
+#define TELLDUS_VID                     0x1781  /* Vendor ID */
+#define TELLDUS_TELLSTICK_PID           0x0C30  /* RF control dongle 433 MHz using FT232RL */
+
+/*
+ * Bayer Ascensia Contour blood glucose meter USB-converter cable.
+ * http://winglucofacts.com/cables/
+ */
+#define BAYER_VID                      0x1A79
+#define BAYER_CONTOUR_CABLE_PID        0x6001
+
+/*
+ * 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
+
+
+
+/*
+ * The Mobility Lab (TML)
+ * Submitted by Pierre Castella
+ */
+#define TML_VID                 0x1B91  /* Vendor ID */
+#define TML_USB_SERIAL_PID      0x0064  /* USB - Serial Converter */
+
+/* Alti-2 products  http://www.alti-2.com */
+#define ALTI2_VID       0x1BC9
+#define ALTI2_N3_PID    0x6001  /* Neptune 3 */
+
+/*
+ * Dresden Elektronik Sensor Terminal Board
+ */
+#define DE_VID                  0x1cf1 /* Vendor ID */
+#define STB_PID                 0x0001 /* Sensor Terminal Board */
+#define WHT_PID                 0x0004 /* Wireless Handheld Terminal */
+
+/*
+ * Papouch products (http://www.papouch.com/)
+ * Submitted by Folkert van Heusden
+ */
+
+#define PAPOUCH_VID                     0x5050  /* Vendor ID */
+#define PAPOUCH_TMU_PID                 0x0400  /* TMU USB Thermometer */
+#define PAPOUCH_QUIDO4x4_PID            0x0900  /* Quido 4/4 Module */
+#define PAPOUCH_AD4USB_PID              0x8003  /* AD4USB Measurement Module */
+
+/*
+ * Marvell SheevaPlug
+ */
+#define MARVELL_VID             0x9e88
+#define MARVELL_SHEEVAPLUG_PID  0x9e8f
+
+/*
+ * Evolution Robotics products (http://www.evolution.com/).
+ * Submitted by Shawn M. Lavelle.
+ */
+#define EVOLUTION_VID           0xDEEE  /* Vendor ID */
+#define EVOLUTION_ER1_PID       0x0300  /* ER1 Control Module */
+#define EVO_8U232AM_PID 0x02FF  /* Evolution robotics RCM2 (FT232AM)*/
+#define EVO_HYBRID_PID          0x0302  /* Evolution robotics RCM4 PID (FT232BM)*/
+#define EVO_RCM4_PID            0x0303  /* Evolution robotics RCM4 PID */
+
+/*
+ * MJS Gadgets HD Radio / XM Radio / Sirius Radio interfaces (using VID 0x0403)
+ */
+#define MJSG_GENERIC_PID        0x9378
+#define MJSG_SR_RADIO_PID       0x9379
+#define MJSG_XM_RADIO_PID       0x937A
+#define MJSG_HD_RADIO_PID       0x937C
diff --git a/drivers/usb/serial/funsoft.c b/drivers/usb/serial/funsoft.c
index d30f736d2cc5..e21ce9ddfc63 100644
--- a/drivers/usb/serial/funsoft.c
+++ b/drivers/usb/serial/funsoft.c
@@ -18,7 +18,7 @@
 
 static int debug;
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x1404, 0xcddc) },
         { },
 };
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 5ac900e5a50e..a42b29a695b2 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -210,7 +210,7 @@ static unsigned char const PRIVATE_REQ[]
 
 
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         /* the same device id seems to be used by all
            usb enabled GPS devices */
         { USB_DEVICE(GARMIN_VENDOR_ID, 3) },
@@ -271,7 +271,6 @@ static void send_to_tty(struct usb_serial_port *port,
                 usb_serial_debug_data(debug, &port->dev,
                                         __func__, actual_length, data);
 
-                tty_buffer_request_room(tty, actual_length);
                 tty_insert_flip_string(tty, data, actual_length);
                 tty_flip_buffer_push(tty);
         }
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index bbe005cefcfb..f804acb138ec 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -20,6 +20,7 @@
 #include <linux/usb/serial.h>
 #include <linux/uaccess.h>
 #include <linux/kfifo.h>
+#include <linux/serial.h>
 
 static int debug;
 
@@ -41,7 +42,7 @@ static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */
 
 /* we want to look at all devices, as the vendor/product id can change
  * depending on the command line argument */
-static struct usb_device_id generic_serial_ids[] = {
+static const struct usb_device_id generic_serial_ids[] = {
         {.driver_info = 42},
         {}
 };
@@ -129,7 +130,7 @@ int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port
         spin_unlock_irqrestore(&port->lock, flags);
 
         /* if we have a bulk endpoint, start reading from it */
-        if (serial->num_bulk_in) {
+        if (port->bulk_in_size) {
                 /* Start reading from the device */
                 usb_fill_bulk_urb(port->read_urb, serial->dev,
                                    usb_rcvbulkpipe(serial->dev,
@@ -158,10 +159,10 @@ static void generic_cleanup(struct usb_serial_port *port)
         dbg("%s - port %d", __func__, port->number);
 
         if (serial->dev) {
-                /* shutdown any bulk reads that might be going on */
-                if (serial->num_bulk_out)
+                /* shutdown any bulk transfers that might be going on */
+                if (port->bulk_out_size)
                         usb_kill_urb(port->write_urb);
-                if (serial->num_bulk_in)
+                if (port->bulk_in_size)
                         usb_kill_urb(port->read_urb);
         }
 }
@@ -194,7 +195,7 @@ static int usb_serial_multi_urb_write(struct tty_struct *tty,
                 if (port->urbs_in_flight >
                     port->serial->type->max_in_flight_urbs) {
                         spin_unlock_irqrestore(&port->lock, flags);
-                        dbg("%s - write limit hit\n", __func__);
+                        dbg("%s - write limit hit", __func__);
                         return bwrite;
                 }
                 port->tx_bytes_flight += towrite;
@@ -276,7 +277,7 @@ static int usb_serial_generic_write_start(struct usb_serial_port *port)
         if (port->write_urb_busy)
                 start_io = false;
         else {
-                start_io = (__kfifo_len(port->write_fifo) != 0);
+                start_io = (kfifo_len(&port->write_fifo) != 0);
                 port->write_urb_busy = start_io;
         }
         spin_unlock_irqrestore(&port->lock, flags);
@@ -285,7 +286,7 @@ static int usb_serial_generic_write_start(struct usb_serial_port *port)
                 return 0;
 
         data = port->write_urb->transfer_buffer;
-        count = kfifo_get(port->write_fifo, data, port->bulk_out_size);
+        count = kfifo_out_locked(&port->write_fifo, data, port->bulk_out_size, &port->lock);
         usb_serial_debug_data(debug, &port->dev, __func__, count, data);
 
         /* set up our urb */
@@ -332,20 +333,20 @@ int usb_serial_generic_write(struct tty_struct *tty,
 
         dbg("%s - port %d", __func__, port->number);
 
+        /* only do something if we have a bulk out endpoint */
+        if (!port->bulk_out_size)
+                return -ENODEV;
+
         if (count == 0) {
                 dbg("%s - write request of 0 bytes", __func__);
                 return 0;
         }
 
-        /* only do something if we have a bulk out endpoint */
-        if (!serial->num_bulk_out)
-                return 0;
-
         if (serial->type->max_in_flight_urbs)
                 return usb_serial_multi_urb_write(tty, port,
                                                   buf, count);
 
-        count = kfifo_put(port->write_fifo, buf, count);
+        count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
         result = usb_serial_generic_write_start(port);
 
         if (result >= 0)
@@ -363,14 +364,19 @@ int usb_serial_generic_write_room(struct tty_struct *tty)
         int room = 0;
 
         dbg("%s - port %d", __func__, port->number);
+
+        if (!port->bulk_out_size)
+                return 0;
+
         spin_lock_irqsave(&port->lock, flags);
         if (serial->type->max_in_flight_urbs) {
                 if (port->urbs_in_flight < serial->type->max_in_flight_urbs)
                         room = port->bulk_out_size *
                                 (serial->type->max_in_flight_urbs -
                                  port->urbs_in_flight);
-        } else if (serial->num_bulk_out)
-                room = port->write_fifo->size - __kfifo_len(port->write_fifo);
+        } else {
+                room = kfifo_avail(&port->write_fifo);
+        }
         spin_unlock_irqrestore(&port->lock, flags);
 
         dbg("%s - returns %d", __func__, room);
@@ -381,17 +387,20 @@ int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct usb_serial *serial = port->serial;
-        int chars = 0;
         unsigned long flags;
+        int chars;
 
         dbg("%s - port %d", __func__, port->number);
 
-        if (serial->type->max_in_flight_urbs) {
-                spin_lock_irqsave(&port->lock, flags);
+        if (!port->bulk_out_size)
+                return 0;
+
+        spin_lock_irqsave(&port->lock, flags);
+        if (serial->type->max_in_flight_urbs)
                 chars = port->tx_bytes_flight;
-                spin_unlock_irqrestore(&port->lock, flags);
-        } else if (serial->num_bulk_out)
-                chars = kfifo_len(port->write_fifo);
+        else
+                chars = kfifo_len(&port->write_fifo);
+        spin_unlock_irqrestore(&port->lock, flags);
 
         dbg("%s - returns %d", __func__, chars);
         return chars;
@@ -414,11 +423,13 @@ void usb_serial_generic_resubmit_read_urb(struct usb_serial_port *port,
                            ((serial->type->read_bulk_callback) ?
                              serial->type->read_bulk_callback :
                              usb_serial_generic_read_bulk_callback), port);
+
         result = usb_submit_urb(urb, mem_flags);
-        if (result)
+        if (result && result != -EPERM) {
                 dev_err(&port->dev,
                         "%s - failed resubmitting read urb, error %d\n",
                                                         __func__, result);
+        }
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_resubmit_read_urb);
 
@@ -489,29 +500,26 @@ void usb_serial_generic_write_bulk_callback(struct urb *urb)
         dbg("%s - port %d", __func__, port->number);
 
         if (port->serial->type->max_in_flight_urbs) {
+                kfree(urb->transfer_buffer);
+
                 spin_lock_irqsave(&port->lock, flags);
                 --port->urbs_in_flight;
                 port->tx_bytes_flight -= urb->transfer_buffer_length;
                 if (port->urbs_in_flight < 0)
                         port->urbs_in_flight = 0;
                 spin_unlock_irqrestore(&port->lock, flags);
-
-                if (status) {
-                        dbg("%s - nonzero multi-urb write bulk status "
-                                "received: %d", __func__, status);
-                        return;
-                }
         } else {
                 port->write_urb_busy = 0;
 
-                if (status) {
-                        dbg("%s - nonzero multi-urb write bulk status "
-                                "received: %d", __func__, status);
-                        kfifo_reset(port->write_fifo);
-                } else
+                if (status)
+                        kfifo_reset_out(&port->write_fifo);
+                else
                         usb_serial_generic_write_start(port);
         }
 
+        if (status)
+                dbg("%s - non-zero urb status: %d", __func__, status);
+
         usb_serial_port_softint(port);
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
@@ -583,7 +591,7 @@ int usb_serial_generic_resume(struct usb_serial *serial)
 
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
-                if (!port->port.count)
+                if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
                         continue;
 
                 if (port->read_urb) {
diff --git a/drivers/usb/serial/hp4x.c b/drivers/usb/serial/hp4x.c
index 431329275133..809379159b0e 100644
--- a/drivers/usb/serial/hp4x.c
+++ b/drivers/usb/serial/hp4x.c
@@ -29,7 +29,7 @@
 #define HP_VENDOR_ID 0x03f0
 #define HP49GP_PRODUCT_ID 0x0121
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(HP_VENDOR_ID, HP49GP_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index b97960ac92f2..3ef8df0ef888 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -364,42 +364,6 @@ static void update_edgeport_E2PROM(struct edgeport_serial *edge_serial)
         release_firmware(fw);
 }
 
-
-/************************************************************************
- *                                                                      *
- *  Get string descriptor from device                                   *
- *                                                                      *
- ************************************************************************/
-static int get_string(struct usb_device *dev, int Id, char *string, int buflen)
-{
-        struct usb_string_descriptor StringDesc;
-        struct usb_string_descriptor *pStringDesc;
-
-        dbg("%s - USB String ID = %d", __func__, Id);
-
-        if (!usb_get_descriptor(dev, USB_DT_STRING, Id,
-                                        &StringDesc, sizeof(StringDesc)))
-                return 0;
-
-        pStringDesc = kmalloc(StringDesc.bLength, GFP_KERNEL);
-        if (!pStringDesc)
-                return 0;
-
-        if (!usb_get_descriptor(dev, USB_DT_STRING, Id,
-                                        pStringDesc, StringDesc.bLength)) {
-                kfree(pStringDesc);
-                return 0;
-        }
-
-        unicode_to_ascii(string, buflen,
-                                pStringDesc->wData, pStringDesc->bLength/2);
-
-        kfree(pStringDesc);
-        dbg("%s - USB String %s", __func__, string);
-        return strlen(string);
-}
-
-
 #if 0
 /************************************************************************
  *
@@ -2007,7 +1971,7 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
                         return;
 
                 case IOSP_EXT_STATUS_RX_CHECK_RSP:
-                        dbg("%s ========== Port %u CHECK_RSP Sequence = %02x =============\n", __func__, edge_serial->rxPort, byte3);
+                        dbg("%s ========== Port %u CHECK_RSP Sequence = %02x =============", __func__, edge_serial->rxPort, byte3);
                         /* Port->RxCheckRsp = true; */
                         return;
                 }
@@ -2075,7 +2039,7 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
                 break;
 
         default:
-                dbg("%s - Unrecognized IOSP status code %u\n", __func__, code);
+                dbg("%s - Unrecognized IOSP status code %u", __func__, code);
                 break;
         }
         return;
@@ -2091,18 +2055,13 @@ static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
 {
         int cnt;
 
-        do {
-                cnt = tty_buffer_request_room(tty, length);
-                if (cnt < length) {
-                        dev_err(dev, "%s - dropping data, %d bytes lost\n",
-                                        __func__, length - cnt);
-                        if (cnt == 0)
-                                break;
-                }
-                tty_insert_flip_string(tty, data, cnt);
-                data += cnt;
-                length -= cnt;
-        } while (length > 0);
+        cnt = tty_insert_flip_string(tty, data, length);
+        if (cnt < length) {
+                dev_err(dev, "%s - dropping data, %d bytes lost\n",
+                                __func__, length - cnt);
+        }
+        data += cnt;
+        length -= cnt;
 
         tty_flip_buffer_push(tty);
 }
@@ -2530,7 +2489,7 @@ static int calc_baud_rate_divisor(int baudrate, int *divisor)
 
                 *divisor = custom;
 
-                dbg("%s - Baud %d = %d\n", __func__, baudrate, custom);
+                dbg("%s - Baud %d = %d", __func__, baudrate, custom);
                 return 0;
         }
 
@@ -2915,7 +2874,7 @@ static void load_application_firmware(struct edgeport_serial *edge_serial)
                         break;
 
                 case EDGE_DOWNLOAD_FILE_NONE:
-                        dbg     ("No download file specified, skipping download\n");
+                        dbg("No download file specified, skipping download");
                         return;
 
                 default:
@@ -2997,10 +2956,12 @@ static int edge_startup(struct usb_serial *serial)
         usb_set_serial_data(serial, edge_serial);
 
         /* get the name for the device from the device */
-        i = get_string(dev, dev->descriptor.iManufacturer,
+        i = usb_string(dev, dev->descriptor.iManufacturer,
             &edge_serial->name[0], MAX_NAME_LEN+1);
+        if (i < 0)
+                i = 0;
         edge_serial->name[i++] = ' ';
-        get_string(dev, dev->descriptor.iProduct,
+        usb_string(dev, dev->descriptor.iProduct,
             &edge_serial->name[i], MAX_NAME_LEN+2 - i);
 
         dev_info(&serial->dev->dev, "%s detected\n", edge_serial->name);
diff --git a/drivers/usb/serial/io_tables.h b/drivers/usb/serial/io_tables.h
index 9241d3147513..feb56a4ca799 100644
--- a/drivers/usb/serial/io_tables.h
+++ b/drivers/usb/serial/io_tables.h
@@ -14,7 +14,7 @@
 #ifndef IO_TABLES_H
 #define IO_TABLES_H
 
-static struct usb_device_id edgeport_2port_id_table [] = {
+static const struct usb_device_id edgeport_2port_id_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_2) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_2I) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_421) },
@@ -23,7 +23,7 @@ static struct usb_device_id edgeport_2port_id_table [] = {
         { }
 };
 
-static struct usb_device_id edgeport_4port_id_table [] = {
+static const struct usb_device_id edgeport_4port_id_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_4) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_RAPIDPORT_4) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_4T) },
@@ -37,7 +37,7 @@ static struct usb_device_id edgeport_4port_id_table [] = {
         { }
 };
 
-static struct usb_device_id edgeport_8port_id_table [] = {
+static const struct usb_device_id edgeport_8port_id_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_8) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_16_DUAL_CPU) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_8I) },
@@ -47,7 +47,7 @@ static struct usb_device_id edgeport_8port_id_table [] = {
         { }
 };
 
-static struct usb_device_id Epic_port_id_table [] = {
+static const struct usb_device_id Epic_port_id_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_NCR, NCR_DEVICE_ID_EPIC_0202) },
         { USB_DEVICE(USB_VENDOR_ID_NCR, NCR_DEVICE_ID_EPIC_0203) },
         { USB_DEVICE(USB_VENDOR_ID_NCR, NCR_DEVICE_ID_EPIC_0310) },
@@ -60,7 +60,7 @@ static struct usb_device_id Epic_port_id_table [] = {
 };
 
 /* Devices that this driver supports */
-static struct usb_device_id id_table_combined [] = {
+static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_4) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_RAPIDPORT_4) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_EDGEPORT_4T) },
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index d4cc0f7af400..aa876f71f228 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -134,7 +134,7 @@ struct edgeport_serial {
 
 
 /* Devices that this driver supports */
-static struct usb_device_id edgeport_1port_id_table [] = {
+static const struct usb_device_id edgeport_1port_id_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },
@@ -154,7 +154,7 @@ static struct usb_device_id edgeport_1port_id_table [] = {
         { }
 };
 
-static struct usb_device_id edgeport_2port_id_table [] = {
+static const struct usb_device_id edgeport_2port_id_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2C) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },
@@ -177,7 +177,7 @@ static struct usb_device_id edgeport_2port_id_table [] = {
 };
 
 /* Devices that this driver supports */
-static struct usb_device_id id_table_combined [] = {
+static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },
         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },
@@ -413,11 +413,18 @@ static int write_boot_mem(struct edgeport_serial *serial,
 {
         int status = 0;
         int i;
-        __u8 temp;
+        u8 *temp;
 
         /* Must do a read before write */
         if (!serial->TiReadI2C) {
-                status = read_boot_mem(serial, 0, 1, &temp);
+                temp = kmalloc(1, GFP_KERNEL);
+                if (!temp) {
+                        dev_err(&serial->serial->dev->dev,
+                                        "%s - out of memory\n", __func__);
+                        return -ENOMEM;
+                }
+                status = read_boot_mem(serial, 0, 1, temp);
+                kfree(temp);
                 if (status)
                         return status;
         }
@@ -935,37 +942,47 @@ static int build_i2c_fw_hdr(__u8 *header, struct device *dev)
 static int i2c_type_bootmode(struct edgeport_serial *serial)
 {
         int status;
-        __u8 data;
+        u8 *data;
+
+        data = kmalloc(1, GFP_KERNEL);
+        if (!data) {
+                dev_err(&serial->serial->dev->dev,
+                                "%s - out of memory\n", __func__);
+                return -ENOMEM;
+        }
 
         /* Try to read type 2 */
         status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
-                                DTK_ADDR_SPACE_I2C_TYPE_II, 0, &data, 0x01);
+                                DTK_ADDR_SPACE_I2C_TYPE_II, 0, data, 0x01);
         if (status)
                 dbg("%s - read 2 status error = %d", __func__, status);
         else
-                dbg("%s - read 2 data = 0x%x", __func__, data);
-        if ((!status) && (data == UMP5152 || data == UMP3410)) {
+                dbg("%s - read 2 data = 0x%x", __func__, *data);
+        if ((!status) && (*data == UMP5152 || *data == UMP3410)) {
                 dbg("%s - ROM_TYPE_II", __func__);
                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
-                return 0;
+                goto out;
         }
 
         /* Try to read type 3 */
         status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
-                                DTK_ADDR_SPACE_I2C_TYPE_III, 0, &data, 0x01);
+                                DTK_ADDR_SPACE_I2C_TYPE_III, 0, data, 0x01);
         if (status)
                 dbg("%s - read 3 status error = %d", __func__, status);
         else
-                dbg("%s - read 2 data = 0x%x", __func__, data);
-        if ((!status) && (data == UMP5152 || data == UMP3410)) {
+                dbg("%s - read 2 data = 0x%x", __func__, *data);
+        if ((!status) && (*data == UMP5152 || *data == UMP3410)) {
                 dbg("%s - ROM_TYPE_III", __func__);
                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;
-                return 0;
+                goto out;
         }
 
         dbg("%s - Unknown", __func__);
         serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
-        return -ENODEV;
+        status = -ENODEV;
+out:
+        kfree(data);
+        return status;
 }
 
 static int bulk_xfer(struct usb_serial *serial, void *buffer,
@@ -1113,7 +1130,7 @@ static int download_fw(struct edgeport_serial *serial)
                                 I2C_DESC_TYPE_FIRMWARE_BASIC, rom_desc);
                 if (start_address != 0) {
                         struct ti_i2c_firmware_rec *firmware_version;
-                        __u8 record;
+                        u8 *record;
 
                         dbg("%s - Found Type FIRMWARE (Type 2) record",
                                                                 __func__);
@@ -1165,6 +1182,15 @@ static int download_fw(struct edgeport_serial *serial)
                                     OperationalMajorVersion,
                                     OperationalMinorVersion);
 
+                                record = kmalloc(1, GFP_KERNEL);
+                                if (!record) {
+                                        dev_err(dev, "%s - out of memory.\n",
+                                                        __func__);
+                                        kfree(firmware_version);
+                                        kfree(rom_desc);
+                                        kfree(ti_manuf_desc);
+                                        return -ENOMEM;
+                                }
                                 /* In order to update the I2C firmware we must
                                  * change the type 2 record to type 0xF2. This
                                  * will force the UMP to come up in Boot Mode.
@@ -1177,13 +1203,14 @@ static int download_fw(struct edgeport_serial *serial)
                                  * firmware will update the record type from
                                  * 0xf2 to 0x02.
                                  */
-                                record = I2C_DESC_TYPE_FIRMWARE_BLANK;
+                                *record = I2C_DESC_TYPE_FIRMWARE_BLANK;
 
                                 /* Change the I2C Firmware record type to
                                    0xf2 to trigger an update */
                                 status = write_rom(serial, start_address,
-                                                sizeof(record), &record);
+                                                sizeof(*record), record);
                                 if (status) {
+                                        kfree(record);
                                         kfree(firmware_version);
                                         kfree(rom_desc);
                                         kfree(ti_manuf_desc);
@@ -1196,19 +1223,21 @@ static int download_fw(struct edgeport_serial *serial)
                                  */
                                 status = read_rom(serial,
                                                         start_address,
-                                                        sizeof(record),
-                                                        &record);
+                                                        sizeof(*record),
+                                                        record);
                                 if (status) {
+                                        kfree(record);
                                         kfree(firmware_version);
                                         kfree(rom_desc);
                                         kfree(ti_manuf_desc);
                                         return status;
                                 }
 
-                                if (record != I2C_DESC_TYPE_FIRMWARE_BLANK) {
+                                if (*record != I2C_DESC_TYPE_FIRMWARE_BLANK) {
                                         dev_err(dev,
                                                 "%s - error resetting device\n",
                                                 __func__);
+                                        kfree(record);
                                         kfree(firmware_version);
                                         kfree(rom_desc);
                                         kfree(ti_manuf_desc);
@@ -1226,6 +1255,7 @@ static int download_fw(struct edgeport_serial *serial)
                                                 __func__, status);
 
                                 /* return an error on purpose. */
+                                kfree(record);
                                 kfree(firmware_version);
                                 kfree(rom_desc);
                                 kfree(ti_manuf_desc);
@@ -1686,7 +1716,7 @@ static void edge_interrupt_callback(struct urb *urb)
         case TIUMP_INTERRUPT_CODE_MSR:  /* MSR */
                 /* Copy MSR from UMP */
                 msr = data[1];
-                dbg("%s - ===== Port %u MSR Status = %02x ======\n",
+                dbg("%s - ===== Port %u MSR Status = %02x ======",
                      __func__, port_number, msr);
                 handle_new_msr(edge_port, msr);
                 break;
@@ -1790,7 +1820,6 @@ static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
 {
         int queued;
 
-        tty_buffer_request_room(tty, length);
         queued = tty_insert_flip_string(tty, data, length);
         if (queued < length)
                 dev_err(dev, "%s - dropping data, %d bytes lost\n",
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index d6231c38813e..3fea9298eb15 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -747,7 +747,6 @@ static void ipaq_read_bulk_callback(struct urb *urb)
 
         tty = tty_port_tty_get(&port->port);
         if (tty && urb->actual_length) {
-                tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
                 bytes_in += urb->actual_length;
diff --git a/drivers/usb/serial/ipw.c b/drivers/usb/serial/ipw.c
index 727d323f092a..e1d07840cee6 100644
--- a/drivers/usb/serial/ipw.c
+++ b/drivers/usb/serial/ipw.c
@@ -134,7 +134,7 @@ enum {
 
 #define IPW_WANTS_TO_SEND       0x30
 
-static struct usb_device_id usb_ipw_ids[] = {
+static const struct usb_device_id usb_ipw_ids[] = {
         { USB_DEVICE(IPW_VID, IPW_PID) },
         { },
 };
@@ -172,7 +172,6 @@ static void ipw_read_bulk_callback(struct urb *urb)
 
         tty = tty_port_tty_get(&port->port);
         if (tty && urb->actual_length) {
-                tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 95d8d26b9a44..4a0f51974232 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -100,7 +100,7 @@ static u8 ir_baud;
 static u8 ir_xbof;
 static u8 ir_add_bof;
 
-static struct usb_device_id ir_id_table[] = {
+static const struct usb_device_id ir_id_table[] = {
         { USB_DEVICE(0x050f, 0x0180) },         /* KC Technology, KC-180 */
         { USB_DEVICE(0x08e9, 0x0100) },         /* XTNDAccess */
         { USB_DEVICE(0x09c4, 0x0011) },         /* ACTiSys ACT-IR2000U */
@@ -445,11 +445,6 @@ static void ir_read_bulk_callback(struct urb *urb)
 
         dbg("%s - port %d", __func__, port->number);
 
-        if (!port->port.count) {
-                dbg("%s - port closed.", __func__);
-                return;
-        }
-
         switch (status) {
         case 0: /* Successful */
                 /*
@@ -462,10 +457,8 @@ static void ir_read_bulk_callback(struct urb *urb)
                 usb_serial_debug_data(debug, &port->dev, __func__,
                                                 urb->actual_length, data);
                 tty = tty_port_tty_get(&port->port);
-                if (tty_buffer_request_room(tty, urb->actual_length - 1)) {
-                        tty_insert_flip_string(tty, data+1, urb->actual_length - 1);
-                        tty_flip_buffer_push(tty);
-                }
+                tty_insert_flip_string(tty, data+1, urb->actual_length - 1);
+                tty_flip_buffer_push(tty);
                 tty_kref_put(tty);
 
                 /*
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index e6e02b178d2b..43f13cf2f016 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -43,7 +43,7 @@ static int debug;
 #define DRIVER_VERSION "v0.11"
 #define DRIVER_DESC "Infinity USB Unlimited Phoenix driver"
 
-static struct usb_device_id id_table[] = {
+static const struct usb_device_id id_table[] = {
         {USB_DEVICE(IUU_USB_VENDOR_ID, IUU_USB_PRODUCT_ID)},
         {}                      /* Terminating entry */
 };
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index f8c4b07033ff..297163c3c610 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -464,13 +464,9 @@ static void	usa26_indat_callback(struct urb *urb)
 
         /* Resubmit urb so we continue receiving */
         urb->dev = port->serial->dev;
-        if (port->port.count) {
-                err = usb_submit_urb(urb, GFP_ATOMIC);
-                if (err != 0)
-                        dbg("%s - resubmit read urb failed. (%d)",
-                                        __func__, err);
-        }
-        return;
+        err = usb_submit_urb(urb, GFP_ATOMIC);
+        if (err != 0)
+                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
 }
 
 /* Outdat handling is common for all devices */
@@ -483,8 +479,7 @@ static void	usa2x_outdat_callback(struct urb *urb)
         p_priv = usb_get_serial_port_data(port);
         dbg("%s - urb %d", __func__, urb == p_priv->out_urbs[1]);
 
-        if (port->port.count)
-                usb_serial_port_softint(port);
+        usb_serial_port_softint(port);
 }
 
 static void     usa26_inack_callback(struct urb *urb)
@@ -615,12 +610,10 @@ static void usa28_indat_callback(struct urb *urb)
 
                 /* Resubmit urb so we continue receiving */
                 urb->dev = port->serial->dev;
-                if (port->port.count) {
-                        err = usb_submit_urb(urb, GFP_ATOMIC);
-                        if (err != 0)
-                                dbg("%s - resubmit read urb failed. (%d)",
-                                                                __func__, err);
-                }
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (err != 0)
+                        dbg("%s - resubmit read urb failed. (%d)",
+                                                        __func__, err);
                 p_priv->in_flip ^= 1;
 
                 urb = p_priv->in_urbs[p_priv->in_flip];
@@ -856,12 +849,9 @@ static void	usa49_indat_callback(struct urb *urb)
 
         /* Resubmit urb so we continue receiving */
         urb->dev = port->serial->dev;
-        if (port->port.count) {
-                err = usb_submit_urb(urb, GFP_ATOMIC);
-                if (err != 0)
-                        dbg("%s - resubmit read urb failed. (%d)",
-                                                        __func__, err);
-        }
+        err = usb_submit_urb(urb, GFP_ATOMIC);
+        if (err != 0)
+                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
 }
 
 static void usa49wg_indat_callback(struct urb *urb)
@@ -904,11 +894,7 @@ static void usa49wg_indat_callback(struct urb *urb)
                                 /* no error on any byte */
                                 i++;
                                 for (x = 1; x < len ; ++x)
-                                        if (port->port.count)
-                                                tty_insert_flip_char(tty,
-                                                                data[i++], 0);
-                                        else
-                                                i++;
+                                        tty_insert_flip_char(tty, data[i++], 0);
                         } else {
                                 /*
                                  * some bytes had errors, every byte has status
@@ -922,14 +908,12 @@ static void usa49wg_indat_callback(struct urb *urb)
                                         if (stat & RXERROR_PARITY)
                                                 flag |= TTY_PARITY;
                                         /* XXX should handle break (0x10) */
-                                        if (port->port.count)
-                                                tty_insert_flip_char(tty,
+                                        tty_insert_flip_char(tty,
                                                         data[i+1], flag);
                                         i += 2;
                                 }
                         }
-                        if (port->port.count)
-                                tty_flip_buffer_push(tty);
+                        tty_flip_buffer_push(tty);
                         tty_kref_put(tty);
                 }
         }
@@ -1013,13 +997,9 @@ static void usa90_indat_callback(struct urb *urb)
 
         /* Resubmit urb so we continue receiving */
         urb->dev = port->serial->dev;
-        if (port->port.count) {
-                err = usb_submit_urb(urb, GFP_ATOMIC);
-                if (err != 0)
-                        dbg("%s - resubmit read urb failed. (%d)",
-                                                        __func__, err);
-        }
-        return;
+        err = usb_submit_urb(urb, GFP_ATOMIC);
+        if (err != 0)
+                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
 }
 
 
@@ -2418,8 +2398,7 @@ static int keyspan_usa90_send_setup(struct usb_serial *serial,
                 msg.portEnabled = 0;
         /* Sending intermediate configs */
         else {
-                if (port->port.count)
-                        msg.portEnabled = 1;
+                msg.portEnabled = 1;
                 msg.txBreak = (p_priv->break_on);
         }
 
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h
index 30771e5b3973..bf3297ddd186 100644
--- a/drivers/usb/serial/keyspan.h
+++ b/drivers/usb/serial/keyspan.h
@@ -456,7 +456,7 @@ static const struct keyspan_device_details *keyspan_devices[] = {
         NULL,
 };
 
-static struct usb_device_id keyspan_ids_combined[] = {
+static const struct usb_device_id keyspan_ids_combined[] = {
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_pre_product_id) },
@@ -497,7 +497,7 @@ static struct usb_driver keyspan_driver = {
 };
 
 /* usb_device_id table for the pre-firmware download keyspan devices */
-static struct usb_device_id keyspan_pre_ids[] = {
+static const struct usb_device_id keyspan_pre_ids[] = {
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_pre_product_id) },
@@ -513,7 +513,7 @@ static struct usb_device_id keyspan_pre_ids[] = {
         { } /* Terminating entry */
 };
 
-static struct usb_device_id keyspan_1port_ids[] = {
+static const struct usb_device_id keyspan_1port_ids[] = {
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_product_id) },
@@ -524,7 +524,7 @@ static struct usb_device_id keyspan_1port_ids[] = {
         { } /* Terminating entry */
 };
 
-static struct usb_device_id keyspan_2port_ids[] = {
+static const struct usb_device_id keyspan_2port_ids[] = {
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) },
@@ -532,7 +532,7 @@ static struct usb_device_id keyspan_2port_ids[] = {
         { } /* Terminating entry */
 };
 
-static struct usb_device_id keyspan_4port_ids[] = {
+static const struct usb_device_id keyspan_4port_ids[] = {
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)},
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wg_product_id)},
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index 1296a097f5c3..185fe9a7d4e0 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -125,7 +125,7 @@ struct keyspan_pda_private {
 #define ENTREGRA_VENDOR_ID              0x1645
 #define ENTREGRA_FAKE_ID                0x8093
 
-static struct usb_device_id id_table_combined [] = {
+static const struct usb_device_id id_table_combined[] = {
 #ifdef KEYSPAN
         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
 #endif
@@ -147,20 +147,20 @@ static struct usb_driver keyspan_pda_driver = {
         .no_dynamic_id =        1,
 };
 
-static struct usb_device_id id_table_std [] = {
+static const struct usb_device_id id_table_std[] = {
         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
         { }                                             /* Terminating entry */
 };
 
 #ifdef KEYSPAN
-static struct usb_device_id id_table_fake [] = {
+static const struct usb_device_id id_table_fake[] = {
         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
         { }                                             /* Terminating entry */
 };
 #endif
 
 #ifdef XIRCOM
-static struct usb_device_id id_table_fake_xircom [] = {
+static const struct usb_device_id id_table_fake_xircom[] = {
         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
         { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
         { }
@@ -429,13 +429,20 @@ static int keyspan_pda_get_modem_info(struct usb_serial *serial,
                                       unsigned char *value)
 {
         int rc;
-        unsigned char data;
+        u8 *data;
+
+        data = kmalloc(1, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
                              3, /* get pins */
                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
-                             0, 0, &data, 1, 2000);
+                             0, 0, data, 1, 2000);
         if (rc >= 0)
-                *value = data;
+                *value = *data;
+
+        kfree(data);
         return rc;
 }
 
@@ -543,7 +550,14 @@ static int keyspan_pda_write(struct tty_struct *tty,
            device how much room it really has.  This is done only on
            scheduler time, since usb_control_msg() sleeps. */
         if (count > priv->tx_room && !in_interrupt()) {
-                unsigned char room;
+                u8 *room;
+
+                room = kmalloc(1, GFP_KERNEL);
+                if (!room) {
+                        rc = -ENOMEM;
+                        goto exit;
+                }
+
                 rc = usb_control_msg(serial->dev,
                                      usb_rcvctrlpipe(serial->dev, 0),
                                      6, /* write_room */
@@ -551,9 +565,14 @@ static int keyspan_pda_write(struct tty_struct *tty,
                                      | USB_DIR_IN,
                                      0, /* value: 0 means "remaining room" */
                                      0, /* index */
-                                     &room,
+                                     room,
                                      1,
                                      2000);
+                if (rc > 0) {
+                        dbg(" roomquery says %d", *room);
+                        priv->tx_room = *room;
+                }
+                kfree(room);
                 if (rc < 0) {
                         dbg(" roomquery failed");
                         goto exit;
@@ -563,8 +582,6 @@ static int keyspan_pda_write(struct tty_struct *tty,
                         rc = -EIO; /* device didn't return any data */
                         goto exit;
                 }
-                dbg(" roomquery says %d", room);
-                priv->tx_room = room;
         }
         if (count > priv->tx_room) {
                 /* we're about to completely fill the Tx buffer, so
@@ -684,18 +701,22 @@ static int keyspan_pda_open(struct tty_struct *tty,
                                         struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
-        unsigned char room;
+        u8 *room;
         int rc = 0;
         struct keyspan_pda_private *priv;
 
         /* find out how much room is in the Tx ring */
+        room = kmalloc(1, GFP_KERNEL);
+        if (!room)
+                return -ENOMEM;
+
         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
                              6, /* write_room */
                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
                              | USB_DIR_IN,
                              0, /* value */
                              0, /* index */
-                             &room,
+                             room,
                              1,
                              2000);
         if (rc < 0) {
@@ -708,8 +729,8 @@ static int keyspan_pda_open(struct tty_struct *tty,
                 goto error;
         }
         priv = usb_get_serial_port_data(port);
-        priv->tx_room = room;
-        priv->tx_throttled = room ? 0 : 1;
+        priv->tx_room = *room;
+        priv->tx_throttled = *room ? 0 : 1;
 
         /*Start reading from the device*/
         port->interrupt_in_urb->dev = serial->dev;
@@ -718,8 +739,8 @@ static int keyspan_pda_open(struct tty_struct *tty,
                 dbg("%s - usb_submit_urb(read int) failed", __func__);
                 goto error;
         }
-
 error:
+        kfree(room);
         return rc;
 }
 static void keyspan_pda_close(struct usb_serial_port *port)
@@ -789,6 +810,13 @@ static int keyspan_pda_fake_startup(struct usb_serial *serial)
         return 1;
 }
 
+#ifdef KEYSPAN
+MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
+#endif
+#ifdef XIRCOM
+MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
+#endif
+
 static int keyspan_pda_startup(struct usb_serial *serial)
 {
 
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index 3a7873806f46..8eef91ba4b1c 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -94,7 +94,7 @@ static int  klsi_105_tiocmset(struct tty_struct *tty, struct file *file,
 /*
  * All of the device info needed for the KLSI converters.
  */
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(PALMCONNECT_VID, PALMCONNECT_PID) },
         { USB_DEVICE(KLSI_VID, KLSI_KL5KUSB105D_PID) },
         { }             /* Terminating entry */
@@ -212,10 +212,19 @@ static int klsi_105_get_line_state(struct usb_serial_port *port,
                                    unsigned long *line_state_p)
 {
         int rc;
-        __u8 status_buf[KLSI_STATUSBUF_LEN] = { -1, -1};
+        u8 *status_buf;
         __u16 status;
 
         dev_info(&port->serial->dev->dev, "sending SIO Poll request\n");
+
+        status_buf = kmalloc(KLSI_STATUSBUF_LEN, GFP_KERNEL);
+        if (!status_buf) {
+                dev_err(&port->dev, "%s - out of memory for status buffer.\n",
+                                __func__);
+                return -ENOMEM;
+        }
+        status_buf[0] = 0xff;
+        status_buf[1] = 0xff;
         rc = usb_control_msg(port->serial->dev,
                              usb_rcvctrlpipe(port->serial->dev, 0),
                              KL5KUSB105A_SIO_POLL,
@@ -236,6 +245,8 @@ static int klsi_105_get_line_state(struct usb_serial_port *port,
 
                 *line_state_p = klsi_105_status2linestate(status);
         }
+
+        kfree(status_buf);
         return rc;
 }
 
@@ -364,7 +375,7 @@ static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
         int rc;
         int i;
         unsigned long line_state;
-        struct klsi_105_port_settings cfg;
+        struct klsi_105_port_settings *cfg;
         unsigned long flags;
 
         dbg("%s port %d", __func__, port->number);
@@ -376,12 +387,18 @@ static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
          * Then read the modem line control and store values in
          * priv->line_state.
          */
-        cfg.pktlen   = 5;
-        cfg.baudrate = kl5kusb105a_sio_b9600;
-        cfg.databits = kl5kusb105a_dtb_8;
-        cfg.unknown1 = 0;
-        cfg.unknown2 = 1;
-        klsi_105_chg_port_settings(port, &cfg);
+        cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
+        if (!cfg) {
+                dev_err(&port->dev, "%s - out of memory for config buffer.\n",
+                                __func__);
+                return -ENOMEM;
+        }
+        cfg->pktlen   = 5;
+        cfg->baudrate = kl5kusb105a_sio_b9600;
+        cfg->databits = kl5kusb105a_dtb_8;
+        cfg->unknown1 = 0;
+        cfg->unknown2 = 1;
+        klsi_105_chg_port_settings(port, cfg);
 
         /* set up termios structure */
         spin_lock_irqsave(&priv->lock, flags);
@@ -391,11 +408,11 @@ static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
         priv->termios.c_lflag = tty->termios->c_lflag;
         for (i = 0; i < NCCS; i++)
                 priv->termios.c_cc[i] = tty->termios->c_cc[i];
-        priv->cfg.pktlen   = cfg.pktlen;
-        priv->cfg.baudrate = cfg.baudrate;
-        priv->cfg.databits = cfg.databits;
-        priv->cfg.unknown1 = cfg.unknown1;
-        priv->cfg.unknown2 = cfg.unknown2;
+        priv->cfg.pktlen   = cfg->pktlen;
+        priv->cfg.baudrate = cfg->baudrate;
+        priv->cfg.databits = cfg->databits;
+        priv->cfg.unknown1 = cfg->unknown1;
+        priv->cfg.unknown2 = cfg->unknown2;
         spin_unlock_irqrestore(&priv->lock, flags);
 
         /* READ_ON and urb submission */
@@ -441,6 +458,7 @@ static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
                 retval = rc;
 
 exit:
+        kfree(cfg);
         return retval;
 } /* klsi_105_open */
 
@@ -681,7 +699,6 @@ static void klsi_105_read_bulk_callback(struct urb *urb)
                         bytes_sent = urb->actual_length - 2;
                 }
 
-                tty_buffer_request_room(tty, bytes_sent);
                 tty_insert_flip_string(tty, data + 2, bytes_sent);
                 tty_flip_buffer_push(tty);
                 tty_kref_put(tty);
@@ -714,10 +731,17 @@ static void klsi_105_set_termios(struct tty_struct *tty,
         unsigned int old_iflag = old_termios->c_iflag;
         unsigned int cflag = tty->termios->c_cflag;
         unsigned int old_cflag = old_termios->c_cflag;
-        struct klsi_105_port_settings cfg;
+        struct klsi_105_port_settings *cfg;
         unsigned long flags;
         speed_t baud;
 
+        cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
+        if (!cfg) {
+                dev_err(&port->dev, "%s - out of memory for config buffer.\n",
+                                __func__);
+                return;
+        }
+
         /* lock while we are modifying the settings */
         spin_lock_irqsave(&priv->lock, flags);
 
@@ -793,11 +817,11 @@ static void klsi_105_set_termios(struct tty_struct *tty,
                 case CS5:
                         dbg("%s - 5 bits/byte not supported", __func__);
                         spin_unlock_irqrestore(&priv->lock, flags);
-                        return ;
+                        goto err;
                 case CS6:
                         dbg("%s - 6 bits/byte not supported", __func__);
                         spin_unlock_irqrestore(&priv->lock, flags);
-                        return ;
+                        goto err;
                 case CS7:
                         priv->cfg.databits = kl5kusb105a_dtb_7;
                         break;
@@ -856,11 +880,13 @@ static void klsi_105_set_termios(struct tty_struct *tty,
 #endif
                 ;
         }
-        memcpy(&cfg, &priv->cfg, sizeof(cfg));
+        memcpy(cfg, &priv->cfg, sizeof(*cfg));
         spin_unlock_irqrestore(&priv->lock, flags);
 
         /* now commit changes to device */
-        klsi_105_chg_port_settings(port, &cfg);
+        klsi_105_chg_port_settings(port, cfg);
+err:
+        kfree(cfg);
 } /* klsi_105_set_termios */
 
 
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index 45ea694b3ae6..c113a2a0e10c 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -86,7 +86,7 @@ static void kobil_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
 static void kobil_init_termios(struct tty_struct *tty);
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_B_PRODUCT_ID) },
         { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_K_PRODUCT_ID) },
         { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_USBTWIN_PRODUCT_ID) },
@@ -388,7 +388,6 @@ static void kobil_read_int_callback(struct urb *urb)
                 */
                 /* END DEBUG */
 
-                tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
@@ -624,7 +623,6 @@ static void kobil_set_termios(struct tty_struct *tty,
         unsigned short urb_val = 0;
         int c_cflag = tty->termios->c_cflag;
         speed_t speed;
-        void *settings;
 
         priv = usb_get_serial_port_data(port);
         if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
@@ -647,25 +645,13 @@ static void kobil_set_termios(struct tty_struct *tty,
         }
         urb_val |= (c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits :
                                                         SUSBCR_SPASB_1StopBit;
-
-        settings = kzalloc(50, GFP_KERNEL);
-        if (!settings)
-                return;
-
-        sprintf(settings, "%d ", speed);
-
         if (c_cflag & PARENB) {
-                if  (c_cflag & PARODD) {
+                if  (c_cflag & PARODD)
                         urb_val |= SUSBCR_SPASB_OddParity;
-                        strcat(settings, "Odd Parity");
-                } else {
+                else
                         urb_val |= SUSBCR_SPASB_EvenParity;
-                        strcat(settings, "Even Parity");
-                }
-        } else {
+        } else
                 urb_val |= SUSBCR_SPASB_NoParity;
-                strcat(settings, "No Parity");
-        }
         tty->termios->c_cflag &= ~CMSPAR;
         tty_encode_baud_rate(tty, speed, speed);
 
@@ -675,11 +661,10 @@ static void kobil_set_termios(struct tty_struct *tty,
                   USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                   urb_val,
                   0,
-                  settings,
+                  NULL,
                   0,
                   KOBIL_TIMEOUT
                 );
-        kfree(settings);
 }
 
 static int kobil_ioctl(struct tty_struct *tty, struct file *file,
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index cd009cb280a5..2849f8c32015 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -75,6 +75,7 @@
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <linux/uaccess.h>
+#include <asm/unaligned.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include "mct_u232.h"
@@ -110,7 +111,7 @@ static void mct_u232_unthrottle(struct tty_struct *tty);
 /*
  * All of the device info needed for the MCT USB-RS232 converter.
  */
-static struct usb_device_id id_table_combined [] = {
+static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
@@ -231,19 +232,22 @@ static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
 static int mct_u232_set_baud_rate(struct tty_struct *tty,
         struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
 {
-        __le32 divisor;
+        unsigned int divisor;
         int rc;
-        unsigned char zero_byte = 0;
+        unsigned char *buf;
         unsigned char cts_enable_byte = 0;
         speed_t speed;
 
-        divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value,
-                                                                &speed));
+        buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
+        if (buf == NULL)
+                return -ENOMEM;
 
+        divisor = mct_u232_calculate_baud_rate(serial, value, &speed);
+        put_unaligned_le32(cpu_to_le32(divisor), buf);
         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                                 MCT_U232_SET_BAUD_RATE_REQUEST,
                                 MCT_U232_SET_REQUEST_TYPE,
-                                0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
+                                0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,
                                 WDR_TIMEOUT);
         if (rc < 0)     /*FIXME: What value speed results */
                 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
@@ -269,10 +273,11 @@ static int mct_u232_set_baud_rate(struct tty_struct *tty,
            a device which is not asserting 'CTS'.
         */
 
+        buf[0] = 0;
         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                                 MCT_U232_SET_UNKNOWN1_REQUEST,
                                 MCT_U232_SET_REQUEST_TYPE,
-                                0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE,
+                                0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,
                                 WDR_TIMEOUT);
         if (rc < 0)
                 dev_err(&port->dev, "Sending USB device request code %d "
@@ -284,30 +289,40 @@ static int mct_u232_set_baud_rate(struct tty_struct *tty,
 
         dbg("set_baud_rate: send second control message, data = %02X",
                                                         cts_enable_byte);
+        buf[0] = cts_enable_byte;
         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                         MCT_U232_SET_CTS_REQUEST,
                         MCT_U232_SET_REQUEST_TYPE,
-                        0, 0, &cts_enable_byte, MCT_U232_SET_CTS_SIZE,
+                        0, 0, buf, MCT_U232_SET_CTS_SIZE,
                         WDR_TIMEOUT);
         if (rc < 0)
                 dev_err(&port->dev, "Sending USB device request code %d "
                         "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
 
+        kfree(buf);
         return rc;
 } /* mct_u232_set_baud_rate */
 
 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
 {
         int rc;
+        unsigned char *buf;
+
+        buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
+        if (buf == NULL)
+                return -ENOMEM;
+
+        buf[0] = lcr;
         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                         MCT_U232_SET_LINE_CTRL_REQUEST,
                         MCT_U232_SET_REQUEST_TYPE,
-                        0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
+                        0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
                         WDR_TIMEOUT);
         if (rc < 0)
                 dev_err(&serial->dev->dev,
                         "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
         dbg("set_line_ctrl: 0x%x", lcr);
+        kfree(buf);
         return rc;
 } /* mct_u232_set_line_ctrl */
 
@@ -315,23 +330,31 @@ static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
                                    unsigned int control_state)
 {
         int rc;
-        unsigned char mcr = MCT_U232_MCR_NONE;
+        unsigned char mcr;
+        unsigned char *buf;
+
+        buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
+        if (buf == NULL)
+                return -ENOMEM;
 
+        mcr = MCT_U232_MCR_NONE;
         if (control_state & TIOCM_DTR)
                 mcr |= MCT_U232_MCR_DTR;
         if (control_state & TIOCM_RTS)
                 mcr |= MCT_U232_MCR_RTS;
 
+        buf[0] = mcr;
         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                         MCT_U232_SET_MODEM_CTRL_REQUEST,
                         MCT_U232_SET_REQUEST_TYPE,
-                        0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
+                        0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
                         WDR_TIMEOUT);
         if (rc < 0)
                 dev_err(&serial->dev->dev,
                         "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
         dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
 
+        kfree(buf);
         return rc;
 } /* mct_u232_set_modem_ctrl */
 
@@ -339,17 +362,27 @@ static int mct_u232_get_modem_stat(struct usb_serial *serial,
                                                 unsigned char *msr)
 {
         int rc;
+        unsigned char *buf;
+
+        buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
+        if (buf == NULL) {
+                *msr = 0;
+                return -ENOMEM;
+        }
         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
                         MCT_U232_GET_MODEM_STAT_REQUEST,
                         MCT_U232_GET_REQUEST_TYPE,
-                        0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
+                        0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
                         WDR_TIMEOUT);
         if (rc < 0) {
                 dev_err(&serial->dev->dev,
                         "Get MODEM STATus failed (error = %d)\n", rc);
                 *msr = 0;
+        } else {
+                *msr = buf[0];
         }
         dbg("get_modem_stat: 0x%x", *msr);
+        kfree(buf);
         return rc;
 } /* mct_u232_get_modem_stat */
 
diff --git a/drivers/usb/serial/mct_u232.h b/drivers/usb/serial/mct_u232.h
index 07b6bec31dc8..7417d5ce1e23 100644
--- a/drivers/usb/serial/mct_u232.h
+++ b/drivers/usb/serial/mct_u232.h
@@ -73,6 +73,8 @@
 #define MCT_U232_SET_CTS_REQUEST   12
 #define MCT_U232_SET_CTS_SIZE       1
 
+#define MCT_U232_MAX_SIZE               4       /* of MCT_XXX_SIZE */
+
 /*
  * Baud rate (divisor)
  * Actually, there are two of them, MCT website calls them "Philips solution"
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index 763e32a44be0..0d47f2c4d59f 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -81,12 +81,15 @@ struct moschip_serial {
 
 static int debug;
 
+static struct usb_serial_driver moschip7720_2port_driver;
+
 #define USB_VENDOR_ID_MOSCHIP           0x9710
 #define MOSCHIP_DEVICE_ID_7720          0x7720
 #define MOSCHIP_DEVICE_ID_7715          0x7715
 
-static struct usb_device_id moschip_port_id_table[] = {
+static const struct usb_device_id moschip_port_id_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) },
+        { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7715) },
         { } /* terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, moschip_port_id_table);
@@ -106,7 +109,7 @@ static void mos7720_interrupt_callback(struct urb *urb)
         __u8 sp1;
         __u8 sp2;
 
-        dbg("%s", " : Entering\n");
+        dbg(" : Entering");
 
         switch (status) {
         case 0:
@@ -186,6 +189,75 @@ exit:
 }
 
 /*
+ * mos7715_interrupt_callback
+ *      this is the 7715's callback function for when we have received data on
+ *      the interrupt endpoint.
+ */
+static void mos7715_interrupt_callback(struct urb *urb)
+{
+        int result;
+        int length;
+        int status = urb->status;
+        __u8 *data;
+        __u8 iir;
+
+        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);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d", __func__,
+                    status);
+                goto exit;
+        }
+
+        length = urb->actual_length;
+        data = urb->transfer_buffer;
+
+        /* Structure of data from 7715 device:
+         * Byte 1: IIR serial Port
+         * Byte 2: unused
+         * Byte 2: DSR parallel port
+         * Byte 4: FIFO status for both */
+
+        if (unlikely(length != 4)) {
+                dbg("Wrong data !!!");
+                return;
+        }
+
+        iir = data[0];
+        if (!(iir & 0x01)) {    /* serial port interrupt pending */
+                switch (iir & 0x0f) {
+                case SERIAL_IIR_RLS:
+                        dbg("Serial Port: Receiver status error or address "
+                            "bit detected in 9-bit mode\n");
+                        break;
+                case SERIAL_IIR_CTI:
+                        dbg("Serial Port: Receiver time out");
+                        break;
+                case SERIAL_IIR_MS:
+                        dbg("Serial Port: Modem status change");
+                        break;
+                }
+        }
+
+exit:
+        result = usb_submit_urb(urb, GFP_ATOMIC);
+        if (result)
+                dev_err(&urb->dev->dev,
+                        "%s - Error %d submitting control urb\n",
+                        __func__, result);
+        return;
+}
+
+/*
  * mos7720_bulk_in_callback
  *      this is the callback function for when we have received data on the
  *      bulk in endpoint.
@@ -206,7 +278,7 @@ static void mos7720_bulk_in_callback(struct urb *urb)
 
         mos7720_port = urb->context;
         if (!mos7720_port) {
-                dbg("%s", "NULL mos7720_port pointer \n");
+                dbg("NULL mos7720_port pointer");
                 return ;
         }
 
@@ -218,7 +290,6 @@ static void mos7720_bulk_in_callback(struct urb *urb)
 
         tty = tty_port_tty_get(&port->port);
         if (tty && urb->actual_length) {
-                tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
@@ -275,17 +346,15 @@ static void mos7720_bulk_out_data_callback(struct urb *urb)
  *      this function will be used for sending command to device
  */
 static int send_mos_cmd(struct usb_serial *serial, __u8 request, __u16 value,
-                        __u16 index, void *data)
+                        __u16 index, u8 *data)
 {
         int status;
-        unsigned int pipe;
+        u8 *buf;
         u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
-        __u8 requesttype;
-        __u16 size = 0x0000;
 
         if (value < MOS_MAX_PORT) {
                 if (product == MOSCHIP_DEVICE_ID_7715)
-                        value = value*0x100+0x100;
+                        value = 0x0200; /* identifies the 7715's serial port */
                 else
                         value = value*0x100+0x200;
         } else {
@@ -298,27 +367,58 @@ static int send_mos_cmd(struct usb_serial *serial, __u8 request, __u16 value,
         }
 
         if (request == MOS_WRITE) {
-                request = (__u8)MOS_WRITE;
-                requesttype = (__u8)0x40;
-                value  = value + (__u16)*((unsigned char *)data);
-                data = NULL;
-                pipe = usb_sndctrlpipe(serial->dev, 0);
+                value = value + *data;
+                status = usb_control_msg(serial->dev,
+                                usb_sndctrlpipe(serial->dev, 0), MOS_WRITE,
+                                0x40, value, index, NULL, 0, MOS_WDR_TIMEOUT);
         } else {
-                request = (__u8)MOS_READ;
-                requesttype = (__u8)0xC0;
-                size = 0x01;
-                pipe = usb_rcvctrlpipe(serial->dev, 0);
+                buf = kmalloc(1, GFP_KERNEL);
+                if (!buf) {
+                        status = -ENOMEM;
+                        goto out;
+                }
+                status = usb_control_msg(serial->dev,
+                                usb_rcvctrlpipe(serial->dev, 0), MOS_READ,
+                                0xc0, value, index, buf, 1, MOS_WDR_TIMEOUT);
+                *data = *buf;
+                kfree(buf);
         }
-
-        status = usb_control_msg(serial->dev, pipe, request, requesttype,
-                                 value, index, data, size, MOS_WDR_TIMEOUT);
-
+out:
         if (status < 0)
-                dbg("Command Write failed Value %x index %x\n", value, index);
+                dbg("Command Write failed Value %x index %x", value, index);
 
         return status;
 }
 
+
+/*
+ * mos77xx_probe
+ *      this function installs the appropriate read interrupt endpoint callback
+ *      depending on whether the device is a 7720 or 7715, thus avoiding costly
+ *      run-time checks in the high-frequency callback routine itself.
+ */
+static int mos77xx_probe(struct usb_serial *serial,
+                         const struct usb_device_id *id)
+{
+        if (id->idProduct == MOSCHIP_DEVICE_ID_7715)
+                moschip7720_2port_driver.read_int_callback =
+                        mos7715_interrupt_callback;
+        else
+                moschip7720_2port_driver.read_int_callback =
+                        mos7720_interrupt_callback;
+
+        return 0;
+}
+
+static int mos77xx_calc_num_ports(struct usb_serial *serial)
+{
+        u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
+        if (product == MOSCHIP_DEVICE_ID_7715)
+                return 1;
+
+        return 2;
+}
+
 static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial *serial;
@@ -390,7 +490,7 @@ static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
           */
         port_number = port->number - port->serial->minor;
         send_mos_cmd(port->serial, MOS_READ, port_number, UART_LSR, &data);
-        dbg("SS::%p LSR:%x\n", mos7720_port, data);
+        dbg("SS::%p LSR:%x", mos7720_port, data);
 
         dbg("Check:Sending Command ..........");
 
@@ -729,7 +829,7 @@ static void mos7720_throttle(struct tty_struct *tty)
         struct moschip_port *mos7720_port;
         int status;
 
-        dbg("%s- port %d\n", __func__, port->number);
+        dbg("%s- port %d", __func__, port->number);
 
         mos7720_port = usb_get_serial_port_data(port);
 
@@ -1208,7 +1308,7 @@ static void mos7720_set_termios(struct tty_struct *tty,
                 return;
         }
 
-        dbg("%s\n", "setting termios - ASPIRE");
+        dbg("setting termios - ASPIRE");
 
         cflag = tty->termios->c_cflag;
 
@@ -1226,7 +1326,7 @@ static void mos7720_set_termios(struct tty_struct *tty,
         change_port_settings(tty, mos7720_port, old_termios);
 
         if (!port->read_urb) {
-                dbg("%s", "URB KILLED !!!!!\n");
+                dbg("URB KILLED !!!!!");
                 return;
         }
 
@@ -1495,6 +1595,7 @@ static int mos7720_startup(struct usb_serial *serial)
         struct usb_device *dev;
         int i;
         char data;
+        u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
 
         dbg("%s: Entering ..........", __func__);
 
@@ -1514,6 +1615,29 @@ static int mos7720_startup(struct usb_serial *serial)
 
         usb_set_serial_data(serial, mos7720_serial);
 
+        /*
+         * The 7715 uses the first bulk in/out endpoint pair for the parallel
+         * port, and the second for the serial port.  Because the usbserial core
+         * assumes both pairs are serial ports, we must engage in a bit of
+         * subterfuge and swap the pointers for ports 0 and 1 in order to make
+         * port 0 point to the serial port.  However, both moschip devices use a
+         * single interrupt-in endpoint for both ports (as mentioned a little
+         * further down), and this endpoint was assigned to port 0.  So after
+         * the swap, we must copy the interrupt endpoint elements from port 1
+         * (as newly assigned) to port 0, and null out port 1 pointers.
+         */
+        if (product == MOSCHIP_DEVICE_ID_7715) {
+                struct usb_serial_port *tmp = serial->port[0];
+                serial->port[0] = serial->port[1];
+                serial->port[1] = tmp;
+                serial->port[0]->interrupt_in_urb = tmp->interrupt_in_urb;
+                serial->port[0]->interrupt_in_buffer = tmp->interrupt_in_buffer;
+                serial->port[0]->interrupt_in_endpointAddress =
+                        tmp->interrupt_in_endpointAddress;
+                serial->port[1]->interrupt_in_urb = NULL;
+                serial->port[1]->interrupt_in_buffer = NULL;
+        }
+
         /* we set up the pointers to the endpoints in the mos7720_open *
          * function, as the structures aren't created yet.             */
 
@@ -1529,7 +1653,7 @@ static int mos7720_startup(struct usb_serial *serial)
 
                 /* Initialize all port interrupt end point to port 0 int
                  * endpoint.  Our device has only one interrupt endpoint
-                 * comman to all ports */
+                 * common to all ports */
                 serial->port[i]->interrupt_in_endpointAddress =
                                 serial->port[0]->interrupt_in_endpointAddress;
 
@@ -1584,11 +1708,12 @@ static struct usb_serial_driver moschip7720_2port_driver = {
         .description            = "Moschip 2 port adapter",
         .usb_driver             = &usb_driver,
         .id_table               = moschip_port_id_table,
-        .num_ports              = 2,
+        .calc_num_ports         = mos77xx_calc_num_ports,
         .open                   = mos7720_open,
         .close                  = mos7720_close,
         .throttle               = mos7720_throttle,
         .unthrottle             = mos7720_unthrottle,
+        .probe                  = mos77xx_probe,
         .attach                 = mos7720_startup,
         .release                = mos7720_release,
         .ioctl                  = mos7720_ioctl,
@@ -1600,7 +1725,7 @@ static struct usb_serial_driver moschip7720_2port_driver = {
         .chars_in_buffer        = mos7720_chars_in_buffer,
         .break_ctl              = mos7720_break,
         .read_bulk_callback     = mos7720_bulk_in_callback,
-        .read_int_callback      = mos7720_interrupt_callback,
+        .read_int_callback      = NULL  /* dynamically assigned in probe() */
 };
 
 static int __init moschip7720_init(void)
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index f11abf52be7d..2fda1c0182b7 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -121,8 +121,15 @@
  * moschip_id_table_combined
  */
 #define USB_VENDOR_ID_BANDB             0x0856
-#define BANDB_DEVICE_ID_USOPTL4_4       0xAC44
-#define BANDB_DEVICE_ID_USOPTL4_2       0xAC42
+#define BANDB_DEVICE_ID_USO9ML2_2       0xAC22
+#define BANDB_DEVICE_ID_USO9ML2_4       0xAC24
+#define BANDB_DEVICE_ID_US9ML2_2        0xAC29
+#define BANDB_DEVICE_ID_US9ML2_4        0xAC30
+#define BANDB_DEVICE_ID_USPTL4_2        0xAC31
+#define BANDB_DEVICE_ID_USPTL4_4        0xAC32
+#define BANDB_DEVICE_ID_USOPTL4_2       0xAC42
+#define BANDB_DEVICE_ID_USOPTL4_4       0xAC44
+#define BANDB_DEVICE_ID_USOPTL2_4       0xAC24
 
 /* This driver also supports
  * ATEN UC2324 device using Moschip MCS7840
@@ -174,21 +181,35 @@
 #define URB_TRANSFER_BUFFER_SIZE        32      /* URB Size  */
 
 
-static struct usb_device_id moschip_port_id_table[] = {
+static const struct usb_device_id moschip_port_id_table[] = {
         {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)},
         {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)},
-        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4)},
         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL2_4)},
         {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2324)},
         {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2322)},
         {}                      /* terminating entry */
 };
 
-static __devinitdata struct usb_device_id moschip_id_table_combined[] = {
+static const struct usb_device_id moschip_id_table_combined[] __devinitconst = {
         {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)},
         {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)},
-        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4)},
         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)},
+        {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL2_4)},
         {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2324)},
         {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2322)},
         {}                      /* terminating entry */
@@ -262,12 +283,19 @@ static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg,
 {
         struct usb_device *dev = port->serial->dev;
         int ret = 0;
+        u8 *buf;
+
+        buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
 
         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
-                              MCS_RD_RTYPE, 0, reg, val, VENDOR_READ_LENGTH,
+                              MCS_RD_RTYPE, 0, reg, buf, VENDOR_READ_LENGTH,
                               MOS_WDR_TIMEOUT);
+        *val = buf[0];
         dbg("mos7840_get_reg_sync offset is %x, return val %x", reg, *val);
-        *val = (*val) & 0x00ff;
+
+        kfree(buf);
         return ret;
 }
 
@@ -320,6 +348,11 @@ static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg,
         struct usb_device *dev = port->serial->dev;
         int ret = 0;
         __u16 Wval;
+        u8 *buf;
+
+        buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
 
         /* dbg("application number is %4x",
             (((__u16)port->number - (__u16)(port->serial->minor))+1)<<8); */
@@ -343,9 +376,11 @@ static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg,
                 }
         }
         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
-                              MCS_RD_RTYPE, Wval, reg, val, VENDOR_READ_LENGTH,
+                              MCS_RD_RTYPE, Wval, reg, buf, VENDOR_READ_LENGTH,
                               MOS_WDR_TIMEOUT);
-        *val = (*val) & 0x00ff;
+        *val = buf[0];
+
+        kfree(buf);
         return ret;
 }
 
@@ -729,7 +764,6 @@ static void mos7840_bulk_in_callback(struct urb *urb)
         if (urb->actual_length) {
                 tty = tty_port_tty_get(&mos7840_port->port->port);
                 if (tty) {
-                        tty_buffer_request_room(tty, urb->actual_length);
                         tty_insert_flip_string(tty, data, urb->actual_length);
                         dbg(" %s ", data);
                         tty_flip_buffer_push(tty);
diff --git a/drivers/usb/serial/moto_modem.c b/drivers/usb/serial/moto_modem.c
index 99bd00f5188a..cf1718394e18 100644
--- a/drivers/usb/serial/moto_modem.c
+++ b/drivers/usb/serial/moto_modem.c
@@ -21,7 +21,7 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x05c6, 0x3197) }, /* unknown Motorola phone */
         { USB_DEVICE(0x0c44, 0x0022) }, /* unknown Mororola phone */
         { USB_DEVICE(0x22b8, 0x2a64) }, /* Motorola KRZR K1m */
diff --git a/drivers/usb/serial/navman.c b/drivers/usb/serial/navman.c
index 5ceaa4c6be09..a6b207c84917 100644
--- a/drivers/usb/serial/navman.c
+++ b/drivers/usb/serial/navman.c
@@ -12,6 +12,7 @@
  *      flags as the navman is rx only so cannot echo.
  */
 
+#include <linux/gfp.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/tty.h>
@@ -22,7 +23,7 @@
 
 static int debug;
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x0a99, 0x0001) }, /* Talon Technology device */
         { },
 };
@@ -66,7 +67,6 @@ static void navman_read_int_callback(struct urb *urb)
 
         tty = tty_port_tty_get(&port->port);
         if (tty && urb->actual_length) {
-                tty_buffer_request_room(tty, urb->actual_length);
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
         }
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index 062265038bf0..89c724c0ac0a 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -75,7 +75,7 @@ static void omninet_disconnect(struct usb_serial *serial);
 static void omninet_release(struct usb_serial *serial);
 static int omninet_attach(struct usb_serial *serial);
 
-static struct usb_device_id id_table[] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(ZYXEL_VENDOR_ID, ZYXEL_OMNINET_ID) },
         { USB_DEVICE(ZYXEL_VENDOR_ID, BT_IGNITIONPRO_ID) },
         { }                                             /* Terminating entry */
@@ -218,8 +218,8 @@ static void omninet_read_bulk_callback(struct urb *urb)
 
         if (debug && header->oh_xxx != 0x30) {
                 if (urb->actual_length) {
-                        printk(KERN_DEBUG __FILE__
-                                        ": omninet_read %d: ", header->oh_len);
+                        printk(KERN_DEBUG "%s: omninet_read %d: ",
+                               __FILE__, header->oh_len);
                         for (i = 0; i < (header->oh_len +
                                                 OMNINET_HEADERLEN); i++)
                                 printk("%.2x ", data[i]);
@@ -332,7 +332,7 @@ static void omninet_write_bulk_callback(struct urb *urb)
         struct usb_serial_port  *port   =  urb->context;
         int status = urb->status;
 
-        dbg("%s - port %0x\n", __func__, port->number);
+        dbg("%s - port %0x", __func__, port->number);
 
         port->write_urb_busy = 0;
         if (status) {
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
index 80f59b6350cb..ed01f3b2de8c 100644
--- a/drivers/usb/serial/opticon.c
+++ b/drivers/usb/serial/opticon.c
@@ -13,6 +13,7 @@
 #include <linux/init.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
+#include <linux/slab.h>
 #include <linux/tty_flip.h>
 #include <linux/serial.h>
 #include <linux/module.h>
@@ -22,7 +23,7 @@
 
 static int debug;
 
-static struct usb_device_id id_table[] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x065a, 0x0009) },
         { },
 };
@@ -55,7 +56,6 @@ static void opticon_bulk_callback(struct urb *urb)
         int status = urb->status;
         struct tty_struct *tty;
         int result;
-        int available_room = 0;
         int data_length;
 
         dbg("%s - port %d", __func__, port->number);
@@ -96,13 +96,9 @@ static void opticon_bulk_callback(struct urb *urb)
                         /* real data, send it to the tty layer */
                         tty = tty_port_tty_get(&port->port);
                         if (tty) {
-                                available_room = tty_buffer_request_room(tty,
-                                                                data_length);
-                                if (available_room) {
-                                        tty_insert_flip_string(tty, data,
-                                                               available_room);
-                                        tty_flip_buffer_push(tty);
-                                }
+                                tty_insert_flip_string(tty, data,
+                                                               data_length);
+                                tty_flip_buffer_push(tty);
                                 tty_kref_put(tty);
                         }
                 } else {
@@ -120,7 +116,7 @@ static void opticon_bulk_callback(struct urb *urb)
                 }
         } else {
                 dev_dbg(&priv->udev->dev,
-                        "Improper ammount of data received from the device, "
+                        "Improper amount of data received from the device, "
                         "%d bytes", urb->actual_length);
         }
 
@@ -217,7 +213,7 @@ static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->outstanding_urbs > URB_UPPER_LIMIT) {
                 spin_unlock_irqrestore(&priv->lock, flags);
-                dbg("%s - write limit hit\n", __func__);
+                dbg("%s - write limit hit", __func__);
                 return 0;
         }
         priv->outstanding_urbs++;
@@ -288,7 +284,7 @@ static int opticon_write_room(struct tty_struct *tty)
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->outstanding_urbs > URB_UPPER_LIMIT * 2 / 3) {
                 spin_unlock_irqrestore(&priv->lock, flags);
-                dbg("%s - write limit hit\n", __func__);
+                dbg("%s - write limit hit", __func__);
                 return 0;
         }
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -501,12 +497,13 @@ static int opticon_resume(struct usb_interface *intf)
         struct usb_serial_port *port = serial->port[0];
         int result;
 
-        mutex_lock(&port->mutex);
-        if (port->port.count)
+        mutex_lock(&port->port.mutex);
+        /* This is protected by the port mutex against close/open */
+        if (test_bit(ASYNCB_INITIALIZED, &port->port.flags))
                 result = usb_submit_urb(priv->bulk_read_urb, GFP_NOIO);
         else
                 result = 0;
-        mutex_unlock(&port->mutex);
+        mutex_unlock(&port->port.mutex);
         return result;
 }
 
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 0577e4b61114..84d0edad8e4f 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -37,6 +37,7 @@
 #include <linux/errno.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
 #include <linux/usb.h>
@@ -288,7 +289,9 @@ static int  option_resume(struct usb_serial *serial);
 
 #define QUALCOMM_VENDOR_ID                      0x05C6
 
-#define MAXON_VENDOR_ID                         0x16d8
+#define CMOTECH_VENDOR_ID                       0x16d8
+#define CMOTECH_PRODUCT_6008                    0x6008
+#define CMOTECH_PRODUCT_6280                    0x6280
 
 #define TELIT_VENDOR_ID                         0x1bc7
 #define TELIT_PRODUCT_UC864E                    0x1003
@@ -302,6 +305,11 @@ static int  option_resume(struct usb_serial *serial);
 #define ZTE_PRODUCT_CDMA_TECH                   0xfffe
 #define ZTE_PRODUCT_AC8710                      0xfff1
 #define ZTE_PRODUCT_AC2726                      0xfff5
+#define ZTE_PRODUCT_AC8710T                     0xffff
+
+/* ZTE PRODUCTS -- alternate vendor ID */
+#define ZTE_VENDOR_ID2                          0x1d6b
+#define ZTE_PRODUCT_MF_330                      0x0002
 
 #define BENQ_VENDOR_ID                          0x04a5
 #define BENQ_PRODUCT_H10                        0x4068
@@ -309,6 +317,7 @@ static int  option_resume(struct usb_serial *serial);
 #define DLINK_VENDOR_ID                         0x1186
 #define DLINK_PRODUCT_DWM_652                   0x3e04
 #define DLINK_PRODUCT_DWM_652_U5                0xce16
+#define DLINK_PRODUCT_DWM_652_U5A               0xce1e
 
 #define QISDA_VENDOR_ID                         0x1da5
 #define QISDA_PRODUCT_H21_4512                  0x4512
@@ -332,15 +341,66 @@ static int  option_resume(struct usb_serial *serial);
 #define ALCATEL_VENDOR_ID                       0x1bbb
 #define ALCATEL_PRODUCT_X060S                   0x0000
 
+#define PIRELLI_VENDOR_ID                       0x1266
+#define PIRELLI_PRODUCT_C100_1                  0x1002
+#define PIRELLI_PRODUCT_C100_2                  0x1003
+#define PIRELLI_PRODUCT_1004                    0x1004
+#define PIRELLI_PRODUCT_1005                    0x1005
+#define PIRELLI_PRODUCT_1006                    0x1006
+#define PIRELLI_PRODUCT_1007                    0x1007
+#define PIRELLI_PRODUCT_1008                    0x1008
+#define PIRELLI_PRODUCT_1009                    0x1009
+#define PIRELLI_PRODUCT_100A                    0x100a
+#define PIRELLI_PRODUCT_100B                    0x100b
+#define PIRELLI_PRODUCT_100C                    0x100c
+#define PIRELLI_PRODUCT_100D                    0x100d
+#define PIRELLI_PRODUCT_100E                    0x100e
+#define PIRELLI_PRODUCT_100F                    0x100f
+#define PIRELLI_PRODUCT_1011                    0x1011
+#define PIRELLI_PRODUCT_1012                    0x1012
+
 /* Airplus products */
 #define AIRPLUS_VENDOR_ID                       0x1011
 #define AIRPLUS_PRODUCT_MCD650                  0x3198
 
+/* Longcheer/Longsung vendor ID; makes whitelabel devices that
+ * many other vendors like 4G Systems, Alcatel, ChinaBird,
+ * Mobidata, etc sell under their own brand names.
+ */
+#define LONGCHEER_VENDOR_ID                     0x1c9e
+
 /* 4G Systems products */
-#define FOUR_G_SYSTEMS_VENDOR_ID                0x1c9e
+/* This is the 4G XS Stick W14 a.k.a. Mobilcom Debitel Surf-Stick *
+ * It seems to contain a Qualcomm QSC6240/6290 chipset            */
 #define FOUR_G_SYSTEMS_PRODUCT_W14              0x9603
 
-static struct usb_device_id option_ids[] = {
+/* Haier products */
+#define HAIER_VENDOR_ID                         0x201e
+#define HAIER_PRODUCT_CE100                     0x2009
+
+#define CINTERION_VENDOR_ID                     0x0681
+
+/* some devices interfaces need special handling due to a number of reasons */
+enum option_blacklist_reason {
+                OPTION_BLACKLIST_NONE = 0,
+                OPTION_BLACKLIST_SENDSETUP = 1,
+                OPTION_BLACKLIST_RESERVED_IF = 2
+};
+
+struct option_blacklist_info {
+        const u32 infolen;      /* number of interface numbers on blacklist */
+        const u8  *ifaceinfo;   /* pointer to the array holding the numbers */
+        enum option_blacklist_reason reason;
+};
+
+static const u8 four_g_w14_no_sendsetup[] = { 0, 1 };
+static const struct option_blacklist_info four_g_w14_blacklist = {
+        .infolen = ARRAY_SIZE(four_g_w14_no_sendsetup),
+        .ifaceinfo = four_g_w14_no_sendsetup,
+        .reason = OPTION_BLACKLIST_SENDSETUP
+};
+
+static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA_LIGHT) },
@@ -516,7 +576,8 @@ static struct usb_device_id option_ids[] = {
         { 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(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6280) }, /* BP3-USB & BP3-EXT HSDPA */
+        { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6008) },
         { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864E) },
         { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_UC864G) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MF622, 0xff, 0xff, 0xff) }, /* ZTE WCDMA products */
@@ -580,18 +641,57 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0086, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0104, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0106, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0108, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0113, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0117, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0118, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0121, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0122, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0123, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0124, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0125, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0126, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0128, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0142, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0143, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0144, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0145, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0146, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0147, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0148, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0149, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0150, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0151, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0152, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0153, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0154, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0155, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0156, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0157, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0158, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0159, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0160, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0161, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0162, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0014, 0xff, 0xff, 0xff) }, /* ZTE CDMA products */
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0027, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0059, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0060, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0070, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0073, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0130, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0141, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC2726, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710T, 0xff, 0xff, 0xff) },
+        { USB_DEVICE(ZTE_VENDOR_ID2, ZTE_PRODUCT_MF_330) },
         { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) },
         { USB_DEVICE(DLINK_VENDOR_ID, DLINK_PRODUCT_DWM_652) },
         { USB_DEVICE(ALINK_VENDOR_ID, DLINK_PRODUCT_DWM_652_U5) }, /* Yes, ALINK_VENDOR_ID */
+        { USB_DEVICE(ALINK_VENDOR_ID, DLINK_PRODUCT_DWM_652_U5A) },
         { USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H21_4512) },
         { USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H21_4523) },
         { USB_DEVICE(QISDA_VENDOR_ID, QISDA_PRODUCT_H20_4515) },
@@ -603,7 +703,29 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X060S) },
         { USB_DEVICE(AIRPLUS_VENDOR_ID, AIRPLUS_PRODUCT_MCD650) },
         { USB_DEVICE(TLAYTECH_VENDOR_ID, TLAYTECH_PRODUCT_TEU800) },
-        { USB_DEVICE(FOUR_G_SYSTEMS_VENDOR_ID, FOUR_G_SYSTEMS_PRODUCT_W14) },
+        { USB_DEVICE(LONGCHEER_VENDOR_ID, FOUR_G_SYSTEMS_PRODUCT_W14),
+          .driver_info = (kernel_ulong_t)&four_g_w14_blacklist
+        },
+        { USB_DEVICE(HAIER_VENDOR_ID, HAIER_PRODUCT_CE100) },
+        /* Pirelli  */
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_C100_1)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_C100_2)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1004)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1005)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1006)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1007)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1008)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1009)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100A)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100B) },
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100C) },
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100D) },
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100E) },
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_100F) },
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1011)},
+        { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_1012)},
+
+        { USB_DEVICE(CINTERION_VENDOR_ID, 0x0047) },
         { } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);
@@ -667,6 +789,7 @@ struct option_intf_private {
         spinlock_t susp_lock;
         unsigned int suspended:1;
         int in_flight;
+        struct option_blacklist_info *blacklist_info;
 };
 
 struct option_port_private {
@@ -726,19 +849,44 @@ static int option_probe(struct usb_serial *serial,
                         const struct usb_device_id *id)
 {
         struct option_intf_private *data;
+
         /* D-Link DWM 652 still exposes CD-Rom emulation interface in modem mode */
         if (serial->dev->descriptor.idVendor == DLINK_VENDOR_ID &&
                 serial->dev->descriptor.idProduct == DLINK_PRODUCT_DWM_652 &&
                 serial->interface->cur_altsetting->desc.bInterfaceClass == 0x8)
                 return -ENODEV;
 
+        /* Bandrich modem and AT command interface is 0xff */
+        if ((serial->dev->descriptor.idVendor == BANDRICH_VENDOR_ID ||
+                serial->dev->descriptor.idVendor == PIRELLI_VENDOR_ID) &&
+                serial->interface->cur_altsetting->desc.bInterfaceClass != 0xff)
+                return -ENODEV;
+
         data = serial->private = kzalloc(sizeof(struct option_intf_private), GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
         spin_lock_init(&data->susp_lock);
+        data->blacklist_info = (struct option_blacklist_info*) id->driver_info;
         return 0;
 }
 
+static enum option_blacklist_reason is_blacklisted(const u8 ifnum,
+                                const struct option_blacklist_info *blacklist)
+{
+        const u8  *info;
+        int i;
+
+        if (blacklist) {
+                info = blacklist->ifaceinfo;
+
+                for (i = 0; i < blacklist->infolen; i++) {
+                        if (info[i] == ifnum)
+                                return blacklist->reason;
+                }
+        }
+        return OPTION_BLACKLIST_NONE;
+}
+
 static void option_set_termios(struct tty_struct *tty,
                 struct usb_serial_port *port, struct ktermios *old_termios)
 {
@@ -879,7 +1027,6 @@ static void option_indat_callback(struct urb *urb)
         } else {
                 tty = tty_port_tty_get(&port->port);
                 if (urb->actual_length) {
-                        tty_buffer_request_room(tty, urb->actual_length);
                         tty_insert_flip_string(tty, data, urb->actual_length);
                         tty_flip_buffer_push(tty);
                 } else 
@@ -887,9 +1034,9 @@ static void option_indat_callback(struct urb *urb)
                 tty_kref_put(tty);
 
                 /* Resubmit urb so we continue receiving */
-                if (port->port.count && status != -ESHUTDOWN) {
+                if (status != -ESHUTDOWN) {
                         err = usb_submit_urb(urb, GFP_ATOMIC);
-                        if (err)
+                        if (err && err != -EPERM)
                                 printk(KERN_ERR "%s: resubmit read urb failed. "
                                         "(%d)", __func__, err);
                         else
@@ -943,7 +1090,7 @@ static void option_instat_callback(struct urb *urb)
                                 (struct usb_ctrlrequest *)urb->transfer_buffer;
 
                 if (!req_pkt) {
-                        dbg("%s: NULL req_pkt\n", __func__);
+                        dbg("%s: NULL req_pkt", __func__);
                         return;
                 }
                 if ((req_pkt->bRequestType == 0xA1) &&
@@ -1169,11 +1316,19 @@ static void option_setup_urbs(struct usb_serial *serial)
 static int option_send_setup(struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
+        struct option_intf_private *intfdata =
+                (struct option_intf_private *) serial->private;
         struct option_port_private *portdata;
         int ifNum = serial->interface->cur_altsetting->desc.bInterfaceNumber;
         int val = 0;
         dbg("%s", __func__);
 
+        if (is_blacklisted(ifNum, intfdata->blacklist_info) ==
+                                                OPTION_BLACKLIST_SENDSETUP) {
+                dbg("No send_setup on blacklisted interface #%d\n", ifNum);
+                return -EIO;
+        }
+
         portdata = usb_get_serial_port_data(port);
 
         if (portdata->dtr_state)
@@ -1312,7 +1467,7 @@ static int option_suspend(struct usb_serial *serial, pm_message_t message)
 
         dbg("%s entered", __func__);
 
-        if (serial->dev->auto_pm) {
+        if (message.event & PM_EVENT_AUTO) {
                 spin_lock_irq(&intfdata->susp_lock);
                 b = intfdata->in_flight;
                 spin_unlock_irq(&intfdata->susp_lock);
@@ -1359,7 +1514,7 @@ static int option_resume(struct usb_serial *serial)
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
                 if (!port->interrupt_in_urb) {
-                        dbg("%s: No interrupt URB for port %d\n", __func__, i);
+                        dbg("%s: No interrupt URB for port %d", __func__, i);
                         continue;
                 }
                 err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index c644e26394b4..deeacdea05db 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -58,7 +58,7 @@
 #define OTI6858_AUTHOR "Tomasz Michal Lukaszewski <FIXME@FIXME>"
 #define OTI6858_VERSION "0.1"
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(OTI6858_VENDOR_ID, OTI6858_PRODUCT_ID) },
         { }
 };
@@ -302,7 +302,7 @@ void send_data(struct work_struct *work)
         struct usb_serial_port *port = priv->port;
         int count = 0, result;
         unsigned long flags;
-        unsigned char allow;
+        u8 *allow;
 
         dbg("%s(port = %d)", __func__, port->number);
 
@@ -321,13 +321,20 @@ void send_data(struct work_struct *work)
                 count = port->bulk_out_size;
 
         if (count != 0) {
+                allow = kmalloc(1, GFP_KERNEL);
+                if (!allow) {
+                        dev_err(&port->dev, "%s(): kmalloc failed\n",
+                                        __func__);
+                        return;
+                }
                 result = usb_control_msg(port->serial->dev,
                                 usb_rcvctrlpipe(port->serial->dev, 0),
                                 OTI6858_REQ_T_CHECK_TXBUFF,
                                 OTI6858_REQ_CHECK_TXBUFF,
-                                count, 0, &allow, 1, 100);
-                if (result != 1 || allow != 0)
+                                count, 0, allow, 1, 100);
+                if (result != 1 || *allow != 0)
                         count = 0;
+                kfree(allow);
         }
 
         if (count == 0) {
@@ -578,9 +585,6 @@ static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port)
         usb_clear_halt(serial->dev, port->write_urb->pipe);
         usb_clear_halt(serial->dev, port->read_urb->pipe);
 
-        if (port->port.count != 1)
-                return 0;
-
         buf = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL);
         if (buf == NULL) {
                 dev_err(&port->dev, "%s(): out of memory!\n", __func__);
@@ -927,10 +931,6 @@ static void oti6858_read_bulk_callback(struct urb *urb)
         spin_unlock_irqrestore(&priv->lock, flags);
 
         if (status != 0) {
-                if (!port->port.count) {
-                        dbg("%s(): port is closed, exiting", __func__);
-                        return;
-                }
                 /*
                 if (status == -EPROTO) {
                         * PL2303 mysteriously fails with -EPROTO reschedule
@@ -954,14 +954,12 @@ static void oti6858_read_bulk_callback(struct urb *urb)
         }
         tty_kref_put(tty);
 
-        /* schedule the interrupt urb if we are still open */
-        if (port->port.count != 0) {
-                port->interrupt_in_urb->dev = port->serial->dev;
-                result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
-                if (result != 0) {
-                        dev_err(&port->dev, "%s(): usb_submit_urb() failed,"
-                                        " error %d\n", __func__, result);
-                }
+        /* schedule the interrupt urb */
+        port->interrupt_in_urb->dev = port->serial->dev;
+        result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
+        if (result != 0 && result != -EPERM) {
+                dev_err(&port->dev, "%s(): usb_submit_urb() failed,"
+                                " error %d\n", __func__, result);
         }
 }
 
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 9ec1a49e2362..c28b1607eacc 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -50,7 +50,7 @@ struct pl2303_buf {
         char            *buf_put;
 };
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
@@ -59,6 +59,7 @@ static struct usb_device_id id_table [] = {
         { 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(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
         { 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) },
@@ -97,6 +98,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
         { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
         { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
+        { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
 
@@ -451,7 +453,6 @@ static void pl2303_send(struct usb_serial_port *port)
                               port->write_urb->transfer_buffer);
 
         port->write_urb->transfer_buffer_length = count;
-        port->write_urb->dev = port->serial->dev;
         result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
         if (result) {
                 dev_err(&port->dev, "%s - failed submitting write urb,"
@@ -769,7 +770,6 @@ static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
                 pl2303_set_termios(tty, port, &tmp_termios);
 
         dbg("%s - submitting read urb", __func__);
-        port->read_urb->dev = serial->dev;
         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
         if (result) {
                 dev_err(&port->dev, "%s - failed submitting read urb,"
@@ -779,7 +779,6 @@ static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
         }
 
         dbg("%s - submitting interrupt urb", __func__);
-        port->interrupt_in_urb->dev = serial->dev;
         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
         if (result) {
                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
@@ -895,10 +894,23 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
+        struct serial_struct ser;
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
 
         switch (cmd) {
+        case TIOCGSERIAL:
+                memset(&ser, 0, sizeof ser);
+                ser.type = PORT_16654;
+                ser.line = port->serial->minor;
+                ser.port = port->number;
+                ser.baud_base = 460800;
+
+                if (copy_to_user((void __user *)arg, &ser, sizeof ser))
+                        return -EFAULT;
+
+                return 0;
+
         case TIOCMIWAIT:
                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
                 return wait_modem_info(port, arg);
@@ -1042,7 +1054,6 @@ static void pl2303_push_data(struct tty_struct *tty,
                 tty_flag = TTY_FRAME;
         dbg("%s - tty_flag = %d", __func__, tty_flag);
 
-        tty_buffer_request_room(tty, urb->actual_length + 1);
         /* overrun is special, not associated with a char */
         if (line_status & UART_OVERRUN_ERROR)
                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
@@ -1072,16 +1083,11 @@ static void pl2303_read_bulk_callback(struct urb *urb)
 
         if (status) {
                 dbg("%s - urb status = %d", __func__, status);
-                if (!port->port.count) {
-                        dbg("%s - port is closed, exiting.", __func__);
-                        return;
-                }
                 if (status == -EPROTO) {
                         /* PL2303 mysteriously fails with -EPROTO reschedule
                          * the read */
                         dbg("%s - caught -EPROTO, resubmitting the urb",
                             __func__);
-                        urb->dev = port->serial->dev;
                         result = usb_submit_urb(urb, GFP_ATOMIC);
                         if (result)
                                 dev_err(&urb->dev->dev, "%s - failed"
@@ -1108,15 +1114,10 @@ static void pl2303_read_bulk_callback(struct urb *urb)
         }
         tty_kref_put(tty);
         /* Schedule the next read _if_ we are still open */
-        if (port->port.count) {
-                urb->dev = port->serial->dev;
-                result = usb_submit_urb(urb, GFP_ATOMIC);
-                if (result)
-                        dev_err(&urb->dev->dev, "%s - failed resubmitting"
-                                " read urb, error %d\n", __func__, result);
-        }
-
-        return;
+        result = usb_submit_urb(urb, GFP_ATOMIC);
+        if (result && result != -EPERM)
+                dev_err(&urb->dev->dev, "%s - failed resubmitting"
+                        " read urb, error %d\n", __func__, result);
 }
 
 static void pl2303_write_bulk_callback(struct urb *urb)
@@ -1146,7 +1147,6 @@ static void pl2303_write_bulk_callback(struct urb *urb)
                 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"
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index d640dc951568..23c09b38b9ec 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -20,6 +20,7 @@
 #define PL2303_PRODUCT_ID_ALDIGA        0x0611
 #define PL2303_PRODUCT_ID_MMX           0x0612
 #define PL2303_PRODUCT_ID_GPRS          0x0609
+#define PL2303_PRODUCT_ID_HCR331        0x331a
 
 #define ATEN_VENDOR_ID          0x0557
 #define ATEN_VENDOR_ID2         0x0547
@@ -134,3 +135,7 @@
 /* Sanwa KB-USB2 multimeter cable (ID: 11ad:0001) */
 #define SANWA_VENDOR_ID         0x11ad
 #define SANWA_PRODUCT_ID        0x0001
+
+/* ADLINK ND-6530 RS232,RS485 and RS422 adapter */
+#define ADLINK_VENDOR_ID        0x0b63
+#define ADLINK_ND6530_PRODUCT_ID       0x6530
diff --git a/drivers/usb/serial/qcaux.c b/drivers/usb/serial/qcaux.c
new file mode 100644
index 000000000000..7e3bea23600b
--- /dev/null
+++ b/drivers/usb/serial/qcaux.c
@@ -0,0 +1,106 @@
+/*
+ * Qualcomm USB Auxiliary Serial Port driver
+ *
+ * Copyright (C) 2008 Greg Kroah-Hartman <greg@kroah.com>
+ * Copyright (C) 2010 Dan Williams <dcbw@redhat.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.
+ *
+ * Devices listed here usually provide a CDC ACM port on which normal modem
+ * AT commands and PPP can be used.  But when that port is in-use by PPP it
+ * cannot be used simultaneously for status or signal strength.  Instead, the
+ * ports here can be queried for that information using the Qualcomm DM
+ * protocol.
+ */
+
+#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>
+
+/* NOTE: for now, only use this driver for devices that provide a CDC-ACM port
+ * for normal AT commands, but also provide secondary USB interfaces for the
+ * QCDM-capable ports.  Devices that do not provide a CDC-ACM port should
+ * probably be driven by option.ko.
+ */
+
+/* UTStarcom/Pantech/Curitel devices */
+#define UTSTARCOM_VENDOR_ID                     0x106c
+#define UTSTARCOM_PRODUCT_PC5740                0x3701
+#define UTSTARCOM_PRODUCT_PC5750                0x3702 /* aka Pantech PX-500 */
+#define UTSTARCOM_PRODUCT_UM150                 0x3711
+#define UTSTARCOM_PRODUCT_UM175_V1              0x3712
+#define UTSTARCOM_PRODUCT_UM175_V2              0x3714
+#define UTSTARCOM_PRODUCT_UM175_ALLTEL          0x3715
+
+/* CMOTECH devices */
+#define CMOTECH_VENDOR_ID                       0x16d8
+#define CMOTECH_PRODUCT_CDU550                  0x5553
+#define CMOTECH_PRODUCT_CDX650                  0x6512
+
+/* LG devices */
+#define LG_VENDOR_ID                            0x1004
+#define LG_PRODUCT_VX4400_6000                  0x6000 /* VX4400/VX6000/Rumor */
+
+/* Sanyo devices */
+#define SANYO_VENDOR_ID                         0x0474
+#define SANYO_PRODUCT_KATANA_LX                 0x0754 /* SCP-3800 (Katana LX) */
+
+static struct usb_device_id id_table[] = {
+        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, UTSTARCOM_PRODUCT_PC5740, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, UTSTARCOM_PRODUCT_PC5750, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, UTSTARCOM_PRODUCT_UM150, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, UTSTARCOM_PRODUCT_UM175_V1, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, UTSTARCOM_PRODUCT_UM175_V2, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, UTSTARCOM_PRODUCT_UM175_ALLTEL, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CDU550, 0xff, 0xff, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CDX650, 0xff, 0xff, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(LG_VENDOR_ID, LG_PRODUCT_VX4400_6000, 0xff, 0xff, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(SANYO_VENDOR_ID, SANYO_PRODUCT_KATANA_LX, 0xff, 0xff, 0x00) },
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+static struct usb_driver qcaux_driver = {
+        .name =         "qcaux",
+        .probe =        usb_serial_probe,
+        .disconnect =   usb_serial_disconnect,
+        .id_table =     id_table,
+        .no_dynamic_id =        1,
+};
+
+static struct usb_serial_driver qcaux_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "qcaux",
+        },
+        .id_table =             id_table,
+        .num_ports =            1,
+};
+
+static int __init qcaux_init(void)
+{
+        int retval;
+
+        retval = usb_serial_register(&qcaux_device);
+        if (retval)
+                return retval;
+        retval = usb_register(&qcaux_driver);
+        if (retval)
+                usb_serial_deregister(&qcaux_device);
+        return retval;
+}
+
+static void __exit qcaux_exit(void)
+{
+        usb_deregister(&qcaux_driver);
+        usb_serial_deregister(&qcaux_device);
+}
+
+module_init(qcaux_init);
+module_exit(qcaux_exit);
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
index 7528b8d57f1c..53a2d5a935a2 100644
--- a/drivers/usb/serial/qcserial.c
+++ b/drivers/usb/serial/qcserial.c
@@ -21,7 +21,7 @@
 
 static int debug;
 
-static struct usb_device_id id_table[] = {
+static const struct usb_device_id id_table[] = {
         {USB_DEVICE(0x05c6, 0x9211)},   /* Acer Gobi QDL device */
         {USB_DEVICE(0x05c6, 0x9212)},   /* Acer Gobi Modem Device */
         {USB_DEVICE(0x03f0, 0x1f1d)},   /* HP un2400 Gobi Modem Device */
@@ -47,6 +47,35 @@ static struct usb_device_id id_table[] = {
         {USB_DEVICE(0x05c6, 0x9221)},   /* Generic Gobi QDL device */
         {USB_DEVICE(0x05c6, 0x9231)},   /* Generic Gobi QDL device */
         {USB_DEVICE(0x1f45, 0x0001)},   /* Unknown Gobi QDL device */
+        {USB_DEVICE(0x413c, 0x8185)},   /* Dell Gobi 2000 QDL device (N0218, VU936) */
+        {USB_DEVICE(0x413c, 0x8186)},   /* Dell Gobi 2000 Modem device (N0218, VU936) */
+        {USB_DEVICE(0x05c6, 0x9224)},   /* Sony Gobi 2000 QDL device (N0279, VU730) */
+        {USB_DEVICE(0x05c6, 0x9225)},   /* Sony Gobi 2000 Modem device (N0279, VU730) */
+        {USB_DEVICE(0x05c6, 0x9244)},   /* Samsung Gobi 2000 QDL device (VL176) */
+        {USB_DEVICE(0x05c6, 0x9245)},   /* Samsung Gobi 2000 Modem device (VL176) */
+        {USB_DEVICE(0x03f0, 0x241d)},   /* HP Gobi 2000 QDL device (VP412) */
+        {USB_DEVICE(0x03f0, 0x251d)},   /* HP Gobi 2000 Modem device (VP412) */
+        {USB_DEVICE(0x05c6, 0x9214)},   /* Acer Gobi 2000 QDL device (VP413) */
+        {USB_DEVICE(0x05c6, 0x9215)},   /* Acer Gobi 2000 Modem device (VP413) */
+        {USB_DEVICE(0x05c6, 0x9264)},   /* Asus Gobi 2000 QDL device (VR305) */
+        {USB_DEVICE(0x05c6, 0x9265)},   /* Asus Gobi 2000 Modem device (VR305) */
+        {USB_DEVICE(0x05c6, 0x9234)},   /* Top Global Gobi 2000 QDL device (VR306) */
+        {USB_DEVICE(0x05c6, 0x9235)},   /* Top Global Gobi 2000 Modem device (VR306) */
+        {USB_DEVICE(0x05c6, 0x9274)},   /* iRex Technologies Gobi 2000 QDL device (VR307) */
+        {USB_DEVICE(0x05c6, 0x9275)},   /* iRex Technologies Gobi 2000 Modem device (VR307) */
+        {USB_DEVICE(0x1199, 0x9000)},   /* Sierra Wireless Gobi 2000 QDL device (VT773) */
+        {USB_DEVICE(0x1199, 0x9001)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9002)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9003)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9004)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9005)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9006)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9007)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9008)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9009)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x900a)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x16d8, 0x8001)},   /* CMDTech Gobi 2000 QDL device (VU922) */
+        {USB_DEVICE(0x16d8, 0x8002)},   /* CMDTech Gobi 2000 Modem device (VU922) */
         { }                             /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, id_table);
diff --git a/drivers/usb/serial/safe_serial.c b/drivers/usb/serial/safe_serial.c
index 4b463cd140ef..43a0cadd5782 100644
--- a/drivers/usb/serial/safe_serial.c
+++ b/drivers/usb/serial/safe_serial.c
@@ -64,8 +64,8 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
+#include <linux/gfp.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
diff --git a/drivers/usb/serial/siemens_mpi.c b/drivers/usb/serial/siemens_mpi.c
index 951ea0c6ba77..cb8195cabfde 100644
--- a/drivers/usb/serial/siemens_mpi.c
+++ b/drivers/usb/serial/siemens_mpi.c
@@ -22,7 +22,7 @@
 #define DRIVER_DESC "Driver for Siemens USB/MPI adapter"
 
 
-static struct usb_device_id id_table[] = {
+static const struct usb_device_id id_table[] = {
         /* Vendor and product id for 6ES7-972-0CB20-0XA0 */
         { USB_DEVICE(0x908, 0x0004) },
         { },
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index 5019325ba25d..ef0bdb08d788 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -16,8 +16,9 @@
   Portions based on the option driver by Matthias Urlichs <smurf@smurf.noris.de>
   Whom based his on the Keyspan driver by Hugh Blemings <hugh@blemings.org>
 */
-
-#define DRIVER_VERSION "v.1.3.8"
+/* Uncomment to log function calls */
+/* #define DEBUG */
+#define DRIVER_VERSION "v.1.7.16"
 #define DRIVER_AUTHOR "Kevin Lloyd, Elina Pasheva, Matthew Safar, Rory Filer"
 #define DRIVER_DESC "USB Driver for Sierra Wireless USB modems"
 
@@ -25,6 +26,7 @@
 #include <linux/jiffies.h>
 #include <linux/errno.h>
 #include <linux/tty.h>
+#include <linux/slab.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/usb.h>
@@ -33,8 +35,10 @@
 #define SWIMS_USB_REQUEST_SetPower      0x00
 #define SWIMS_USB_REQUEST_SetNmea       0x07
 
-#define N_IN_URB        8
-#define N_OUT_URB       64
+#define N_IN_URB_HM     8
+#define N_OUT_URB_HM    64
+#define N_IN_URB        4
+#define N_OUT_URB       4
 #define IN_BUFLEN       4096
 
 #define MAX_TRANSFER            (PAGE_SIZE - 512)
@@ -124,6 +128,23 @@ static int is_blacklisted(const u8 ifnum,
         return 0;
 }
 
+static int is_himemory(const u8 ifnum,
+                                const struct sierra_iface_info *himemorylist)
+{
+        const u8  *info;
+        int i;
+
+        if (himemorylist) {
+                info = himemorylist->ifaceinfo;
+
+                for (i=0; i < himemorylist->infolen; i++) {
+                        if (info[i] == ifnum)
+                                return 1;
+                }
+        }
+        return 0;
+}
+
 static int sierra_calc_interface(struct usb_serial *serial)
 {
         int interface;
@@ -186,15 +207,30 @@ static int sierra_probe(struct usb_serial *serial,
         return result;
 }
 
+/* interfaces with higher memory requirements */
+static const u8 hi_memory_typeA_ifaces[] = { 0, 2 };
+static const struct sierra_iface_info typeA_interface_list = {
+        .infolen = ARRAY_SIZE(hi_memory_typeA_ifaces),
+        .ifaceinfo = hi_memory_typeA_ifaces,
+};
+
+static const u8 hi_memory_typeB_ifaces[] = { 3, 4, 5, 6 };
+static const struct sierra_iface_info typeB_interface_list = {
+        .infolen = ARRAY_SIZE(hi_memory_typeB_ifaces),
+        .ifaceinfo = hi_memory_typeB_ifaces,
+};
+
+/* 'blacklist' of interfaces not served by this driver */
 static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11 };
 static const struct sierra_iface_info direct_ip_interface_blacklist = {
         .infolen = ARRAY_SIZE(direct_ip_non_serial_ifaces),
         .ifaceinfo = direct_ip_non_serial_ifaces,
 };
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x0F3D, 0x0112) }, /* Airprime/Sierra PC 5220 */
         { USB_DEVICE(0x03F0, 0x1B1D) }, /* HP ev2200 a.k.a MC5720 */
+        { USB_DEVICE(0x03F0, 0x211D) }, /* HP ev2210 a.k.a MC5725 */
         { USB_DEVICE(0x03F0, 0x1E1D) }, /* HP hs2300 a.k.a MC8775 */
 
         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
@@ -264,21 +300,12 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x1199, 0x68A3),   /* Sierra Wireless Direct IP modems */
           .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
         },
+       { USB_DEVICE(0x413C, 0x08133) }, /* Dell Computer Corp. Wireless 5720 VZW Mobile Broadband (EVDO Rev-A) Minicard GPS Port */
 
         { }
 };
 MODULE_DEVICE_TABLE(usb, id_table);
 
-static struct usb_driver sierra_driver = {
-        .name       = "sierra",
-        .probe      = usb_serial_probe,
-        .disconnect = usb_serial_disconnect,
-        .suspend    = usb_serial_suspend,
-        .resume     = usb_serial_resume,
-        .id_table   = id_table,
-        .no_dynamic_id =        1,
-        .supports_autosuspend = 1,
-};
 
 struct sierra_port_private {
         spinlock_t lock;        /* lock the structure */
@@ -286,8 +313,10 @@ struct sierra_port_private {
         struct usb_anchor active;
         struct usb_anchor delayed;
 
+        int num_out_urbs;
+        int num_in_urbs;
         /* Input endpoints and buffers for this port */
-        struct urb *in_urbs[N_IN_URB];
+        struct urb *in_urbs[N_IN_URB_HM];
 
         /* Settings for the port */
         int rts_state;  /* Handshaking pins (outputs) */
@@ -440,7 +469,7 @@ static void sierra_outdat_callback(struct urb *urb)
 static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
                                         const unsigned char *buf, int count)
 {
-        struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+        struct sierra_port_private *portdata;
         struct sierra_intf_private *intfdata;
         struct usb_serial *serial = port->serial;
         unsigned long flags;
@@ -460,7 +489,7 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
         spin_lock_irqsave(&portdata->lock, flags);
         dev_dbg(&port->dev, "%s - outstanding_urbs: %d\n", __func__,
                 portdata->outstanding_urbs);
-        if (portdata->outstanding_urbs > N_OUT_URB) {
+        if (portdata->outstanding_urbs > portdata->num_out_urbs) {
                 spin_unlock_irqrestore(&portdata->lock, flags);
                 dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
                 return 0;
@@ -567,14 +596,15 @@ static void sierra_indat_callback(struct urb *urb)
         } else {
                 if (urb->actual_length) {
                         tty = tty_port_tty_get(&port->port);
-
-                        tty_buffer_request_room(tty, urb->actual_length);
-                        tty_insert_flip_string(tty, data, urb->actual_length);
-                        tty_flip_buffer_push(tty);
-
-                        tty_kref_put(tty);
-                        usb_serial_debug_data(debug, &port->dev, __func__,
-                                urb->actual_length, data);
+                        if (tty) {
+                                tty_insert_flip_string(tty, data,
+                                        urb->actual_length);
+                                tty_flip_buffer_push(tty);
+
+                                tty_kref_put(tty);
+                                usb_serial_debug_data(debug, &port->dev,
+                                        __func__, urb->actual_length, data);
+                        }
                 } else {
                         dev_dbg(&port->dev, "%s: empty read urb"
                                 " received\n", __func__);
@@ -582,10 +612,10 @@ static void sierra_indat_callback(struct urb *urb)
         }
 
         /* Resubmit urb so we continue receiving */
-        if (port->port.count && status != -ESHUTDOWN && status != -EPERM) {
+        if (status != -ESHUTDOWN && status != -EPERM) {
                 usb_mark_last_busy(port->serial->dev);
                 err = usb_submit_urb(urb, GFP_ATOMIC);
-                if (err)
+                if (err && err != -EPERM)
                         dev_err(&port->dev, "resubmit read urb failed."
                                 "(%d)\n", err);
         }
@@ -644,11 +674,11 @@ static void sierra_instat_callback(struct urb *urb)
                 dev_dbg(&port->dev, "%s: error %d\n", __func__, status);
 
         /* Resubmit urb so we continue receiving IRQ data */
-        if (port->port.count && status != -ESHUTDOWN && status != -ENOENT) {
+        if (status != -ESHUTDOWN && status != -ENOENT) {
                 usb_mark_last_busy(serial->dev);
                 urb->dev = serial->dev;
                 err = usb_submit_urb(urb, GFP_ATOMIC);
-                if (err)
+                if (err && err != -EPERM)
                         dev_err(&port->dev, "%s: resubmit intr urb "
                                 "failed. (%d)\n", __func__, err);
         }
@@ -665,7 +695,7 @@ static int sierra_write_room(struct tty_struct *tty)
         /* try to give a good number back based on if we have any free urbs at
          * this point in time */
         spin_lock_irqsave(&portdata->lock, flags);
-        if (portdata->outstanding_urbs > N_OUT_URB * 2 / 3) {
+        if (portdata->outstanding_urbs > (portdata->num_out_urbs * 2) / 3) {
                 spin_unlock_irqrestore(&portdata->lock, flags);
                 dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
                 return 0;
@@ -680,7 +710,7 @@ static void sierra_stop_rx_urbs(struct usb_serial_port *port)
         int i;
         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
 
-        for (i = 0; i < ARRAY_SIZE(portdata->in_urbs); i++)
+        for (i = 0; i < portdata->num_in_urbs; i++)
                 usb_kill_urb(portdata->in_urbs[i]);
 
         usb_kill_urb(port->interrupt_in_urb);
@@ -695,7 +725,7 @@ static int sierra_submit_rx_urbs(struct usb_serial_port *port, gfp_t mem_flags)
         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
 
         ok_cnt = 0;
-        for (i = 0; i < ARRAY_SIZE(portdata->in_urbs); i++) {
+        for (i = 0; i < portdata->num_in_urbs; i++) {
                 urb = portdata->in_urbs[i];
                 if (!urb)
                         continue;
@@ -791,7 +821,7 @@ static void sierra_close(struct usb_serial_port *port)
                 /* Stop reading urbs */
                 sierra_stop_rx_urbs(port);
                 /* .. and release them */
-                for (i = 0; i < N_IN_URB; i++) {
+                for (i = 0; i < portdata->num_in_urbs; i++) {
                         sierra_release_urb(portdata->in_urbs[i]);
                         portdata->in_urbs[i] = NULL;
                 }
@@ -818,7 +848,7 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
 
 
         endpoint = port->bulk_in_endpointAddress;
-        for (i = 0; i < ARRAY_SIZE(portdata->in_urbs); i++) {
+        for (i = 0; i < portdata->num_in_urbs; i++) {
                 urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port,
                                         IN_BUFLEN, GFP_KERNEL,
                                         sierra_indat_callback);
@@ -869,7 +899,9 @@ static int sierra_startup(struct usb_serial *serial)
 {
         struct usb_serial_port *port;
         struct sierra_port_private *portdata;
+        struct sierra_iface_info *himemoryp = NULL;
         int i;
+        u8 ifnum;
 
         dev_dbg(&serial->dev->dev, "%s\n", __func__);
 
@@ -886,13 +918,40 @@ static int sierra_startup(struct usb_serial *serial)
                 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
                 if (!portdata) {
                         dev_dbg(&port->dev, "%s: kmalloc for "
-                                "sierra_port_private (%d) failed!.\n",
+                                "sierra_port_private (%d) failed!\n",
                                 __func__, i);
                         return -ENOMEM;
                 }
                 spin_lock_init(&portdata->lock);
                 init_usb_anchor(&portdata->active);
                 init_usb_anchor(&portdata->delayed);
+                ifnum = i;
+                /* Assume low memory requirements */
+                portdata->num_out_urbs = N_OUT_URB;
+                portdata->num_in_urbs  = N_IN_URB;
+
+                /* Determine actual memory requirements */
+                if (serial->num_ports == 1) {
+                        /* Get interface number for composite device */
+                        ifnum = sierra_calc_interface(serial);
+                        himemoryp =
+                            (struct sierra_iface_info *)&typeB_interface_list;
+                        if (is_himemory(ifnum, himemoryp)) {
+                                portdata->num_out_urbs = N_OUT_URB_HM;
+                                portdata->num_in_urbs  = N_IN_URB_HM;
+                        }
+                }
+                else {
+                        himemoryp =
+                            (struct sierra_iface_info *)&typeA_interface_list;
+                        if (is_himemory(i, himemoryp)) {
+                                portdata->num_out_urbs = N_OUT_URB_HM;
+                                portdata->num_in_urbs  = N_IN_URB_HM;
+                        }
+                }
+                dev_dbg(&serial->dev->dev,
+                        "Memory usage (urbs) interface #%d, in=%d, out=%d\n",
+                        ifnum,portdata->num_in_urbs, portdata->num_out_urbs );
                 /* Set the port private data pointer */
                 usb_set_serial_port_data(port, portdata);
         }
@@ -940,7 +999,7 @@ static int sierra_suspend(struct usb_serial *serial, pm_message_t message)
         struct sierra_intf_private *intfdata;
         int b;
 
-        if (serial->dev->auto_pm) {
+        if (message.event & PM_EVENT_AUTO) {
                 intfdata = serial->private;
                 spin_lock_irq(&intfdata->susp_lock);
                 b = intfdata->in_flight;
@@ -995,11 +1054,31 @@ static int sierra_resume(struct usb_serial *serial)
 
         return ec ? -EIO : 0;
 }
+
+static int sierra_reset_resume(struct usb_interface *intf)
+{
+        struct usb_serial *serial = usb_get_intfdata(intf);
+        dev_err(&serial->dev->dev, "%s\n", __func__);
+        return usb_serial_resume(intf);
+}
 #else
 #define sierra_suspend NULL
 #define sierra_resume NULL
+#define sierra_reset_resume NULL
 #endif
 
+static struct usb_driver sierra_driver = {
+        .name       = "sierra",
+        .probe      = usb_serial_probe,
+        .disconnect = usb_serial_disconnect,
+        .suspend    = usb_serial_suspend,
+        .resume     = usb_serial_resume,
+        .reset_resume = sierra_reset_resume,
+        .id_table   = id_table,
+        .no_dynamic_id =        1,
+        .supports_autosuspend = 1,
+};
+
 static struct usb_serial_driver sierra_device = {
         .driver = {
                 .owner =        THIS_MODULE,
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c
index 1e58220403d1..5d39191e7244 100644
--- a/drivers/usb/serial/spcp8x5.c
+++ b/drivers/usb/serial/spcp8x5.c
@@ -45,7 +45,7 @@ static int debug;
 #define SPCP8x5_835_VID         0x04fc
 #define SPCP8x5_835_PID         0x0231
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(SPCP8x5_PHILIPS_VID , SPCP8x5_PHILIPS_PID)},
         { USB_DEVICE(SPCP8x5_INTERMATIC_VID, SPCP8x5_INTERMATIC_PID)},
         { USB_DEVICE(SPCP8x5_835_VID, SPCP8x5_835_PID)},
@@ -609,7 +609,7 @@ static void spcp8x5_set_termios(struct tty_struct *tty,
         if (i < 0)
                 dev_err(&port->dev, "Set UART format %#x failed (error = %d)\n",
                         uartdata, i);
-        dbg("0x21:0x40:0:0  %d\n", i);
+        dbg("0x21:0x40:0:0  %d", i);
 
         if (cflag & CRTSCTS) {
                 /* enable hardware flow control */
@@ -677,7 +677,6 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
         struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         unsigned long flags;
-        int i;
         int result = urb->status;
         u8 status;
         char tty_flag;
@@ -687,8 +686,6 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
 
         /* check the urb status */
         if (result) {
-                if (!port->port.count)
-                        return;
                 if (result == -EPROTO) {
                         /* spcp8x5 mysteriously fails with -EPROTO */
                         /* reschedule the read */
@@ -726,26 +723,20 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
 
         tty = tty_port_tty_get(&port->port);
         if (tty && urb->actual_length) {
-                tty_buffer_request_room(tty, urb->actual_length + 1);
                 /* overrun is special, not associated with a char */
                 if (status & UART_OVERRUN_ERROR)
                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-                for (i = 0; i < urb->actual_length; ++i)
-                        tty_insert_flip_char(tty, data[i], tty_flag);
+                tty_insert_flip_string_fixed_flag(tty, data,
+                                                urb->actual_length, tty_flag);
                 tty_flip_buffer_push(tty);
         }
         tty_kref_put(tty);
 
-        /* Schedule the next read _if_ we are still open */
-        if (port->port.count) {
-                urb->dev = port->serial->dev;
-                result = usb_submit_urb(urb , GFP_ATOMIC);
-                if (result)
-                        dev_dbg(&port->dev, "failed submitting read urb %d\n",
-                                result);
-        }
-
-        return;
+        /* Schedule the next read */
+        urb->dev = port->serial->dev;
+        result = usb_submit_urb(urb , GFP_ATOMIC);
+        if (result)
+                dev_dbg(&port->dev, "failed submitting read urb %d\n", result);
 }
 
 /* get data from ring buffer and then write to usb bus */
diff --git a/drivers/usb/serial/symbolserial.c b/drivers/usb/serial/symbolserial.c
index b282c0f2d8e5..d9457bd4fe10 100644
--- a/drivers/usb/serial/symbolserial.c
+++ b/drivers/usb/serial/symbolserial.c
@@ -12,6 +12,7 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/tty.h>
+#include <linux/slab.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
@@ -21,7 +22,7 @@
 
 static int debug;
 
-static struct usb_device_id id_table[] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x05e0, 0x0600) },
         { },
 };
@@ -51,7 +52,6 @@ static void symbol_int_callback(struct urb *urb)
         int status = urb->status;
         struct tty_struct *tty;
         int result;
-        int available_room = 0;
         int data_length;
 
         dbg("%s - port %d", __func__, port->number);
@@ -89,18 +89,13 @@ static void symbol_int_callback(struct urb *urb)
                  */
                 tty = tty_port_tty_get(&port->port);
                 if (tty) {
-                        available_room = tty_buffer_request_room(tty,
-                                                        data_length);
-                        if (available_room) {
-                                tty_insert_flip_string(tty, &data[1],
-                                                       available_room);
-                                tty_flip_buffer_push(tty);
-                        }
+                        tty_insert_flip_string(tty, &data[1], data_length);
+                        tty_flip_buffer_push(tty);
                         tty_kref_put(tty);
                 }
         } else {
                 dev_dbg(&priv->udev->dev,
-                        "Improper ammount of data received from the device, "
+                        "Improper amount of data received from the device, "
                         "%d bytes", urb->actual_length);
         }
 
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 1e9dc8821698..e1bfda33f5b9 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -172,7 +172,7 @@ static unsigned int product_5052_count;
 /* the array dimension is the number of default entries plus */
 /* TI_EXTRA_VID_PID_COUNT user defined entries plus 1 terminating */
 /* null entry */
-static struct usb_device_id ti_id_table_3410[10+TI_EXTRA_VID_PID_COUNT+1] = {
+static struct usb_device_id ti_id_table_3410[13+TI_EXTRA_VID_PID_COUNT+1] = {
         { USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
         { USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_NO_FW_PRODUCT_ID) },
@@ -180,6 +180,9 @@ static struct usb_device_id ti_id_table_3410[10+TI_EXTRA_VID_PID_COUNT+1] = {
         { USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_PRODUCT_ID) },
         { USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_PRODUCT_ID) },
         { USB_DEVICE(MTS_VENDOR_ID, MTS_EDGE_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234MU_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234ZBA_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234ZBAOLD_PRODUCT_ID) },
         { USB_DEVICE(IBM_VENDOR_ID, IBM_4543_PRODUCT_ID) },
         { USB_DEVICE(IBM_VENDOR_ID, IBM_454B_PRODUCT_ID) },
         { USB_DEVICE(IBM_VENDOR_ID, IBM_454C_PRODUCT_ID) },
@@ -192,7 +195,7 @@ static struct usb_device_id ti_id_table_5052[5+TI_EXTRA_VID_PID_COUNT+1] = {
         { USB_DEVICE(TI_VENDOR_ID, TI_5052_FIRMWARE_PRODUCT_ID) },
 };
 
-static struct usb_device_id ti_id_table_combined[14+2*TI_EXTRA_VID_PID_COUNT+1] = {
+static struct usb_device_id ti_id_table_combined[17+2*TI_EXTRA_VID_PID_COUNT+1] = {
         { USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
         { USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_NO_FW_PRODUCT_ID) },
@@ -200,6 +203,9 @@ static struct usb_device_id ti_id_table_combined[14+2*TI_EXTRA_VID_PID_COUNT+1]
         { USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_PRODUCT_ID) },
         { USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_PRODUCT_ID) },
         { USB_DEVICE(MTS_VENDOR_ID, MTS_EDGE_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234MU_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234ZBA_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234ZBAOLD_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_5052_BOOT_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_5152_BOOT_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_5052_EEPROM_PRODUCT_ID) },
@@ -287,6 +293,8 @@ MODULE_FIRMWARE("ti_5052.fw");
 MODULE_FIRMWARE("mts_cdma.fw");
 MODULE_FIRMWARE("mts_gsm.fw");
 MODULE_FIRMWARE("mts_edge.fw");
+MODULE_FIRMWARE("mts_mt9234mu.fw");
+MODULE_FIRMWARE("mts_mt9234zba.fw");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Enable debugging, 0=no, 1=yes");
@@ -1271,14 +1279,13 @@ static void ti_recv(struct device *dev, struct tty_struct *tty,
         int cnt;
 
         do {
-                cnt = tty_buffer_request_room(tty, length);
+                cnt = tty_insert_flip_string(tty, data, length);
                 if (cnt < length) {
                         dev_err(dev, "%s - dropping data, %d bytes lost\n",
                                                 __func__, length - cnt);
                         if (cnt == 0)
                                 break;
                 }
-                tty_insert_flip_string(tty, data, cnt);
                 tty_flip_buffer_push(tty);
                 data += cnt;
                 length -= cnt;
@@ -1688,6 +1695,7 @@ static int ti_download_firmware(struct ti_device *tdev)
         const struct firmware *fw_p;
         char buf[32];
 
+        dbg("%s\n", __func__);
         /* try ID specific firmware first, then try generic firmware */
         sprintf(buf, "ti_usb-v%04x-p%04x.fw", dev->descriptor.idVendor,
             dev->descriptor.idProduct);
@@ -1704,7 +1712,15 @@ static int ti_download_firmware(struct ti_device *tdev)
                         case MTS_EDGE_PRODUCT_ID:
                                 strcpy(buf, "mts_edge.fw");
                                 break;
-                        }
+                        case MTS_MT9234MU_PRODUCT_ID:
+                                strcpy(buf, "mts_mt9234mu.fw");
+                                break;
+                        case MTS_MT9234ZBA_PRODUCT_ID:
+                                strcpy(buf, "mts_mt9234zba.fw");
+                                break;
+                        case MTS_MT9234ZBAOLD_PRODUCT_ID:
+                                strcpy(buf, "mts_mt9234zba.fw");
+                                break;                  }
                 }
                 if (buf[0] == '\0') {
                         if (tdev->td_is_3410)
@@ -1719,7 +1735,7 @@ static int ti_download_firmware(struct ti_device *tdev)
                 return -ENOENT;
         }
         if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
-                dev_err(&dev->dev, "%s - firmware too large\n", __func__);
+                dev_err(&dev->dev, "%s - firmware too large %zu\n", __func__, fw_p->size);
                 return -ENOENT;
         }
 
@@ -1731,6 +1747,7 @@ static int ti_download_firmware(struct ti_device *tdev)
                 status = ti_do_download(dev, pipe, buffer, fw_p->size);
                 kfree(buffer);
         } else {
+                dbg("%s ENOMEM\n", __func__);
                 status = -ENOMEM;
         }
         release_firmware(fw_p);
diff --git a/drivers/usb/serial/ti_usb_3410_5052.h b/drivers/usb/serial/ti_usb_3410_5052.h
index f323c6025858..2aac1953993b 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.h
+++ b/drivers/usb/serial/ti_usb_3410_5052.h
@@ -45,6 +45,9 @@
 #define MTS_CDMA_PRODUCT_ID             0xF110
 #define MTS_GSM_PRODUCT_ID              0xF111
 #define MTS_EDGE_PRODUCT_ID             0xF112
+#define MTS_MT9234MU_PRODUCT_ID         0xF114
+#define MTS_MT9234ZBA_PRODUCT_ID        0xF115
+#define MTS_MT9234ZBAOLD_PRODUCT_ID     0x0319
 
 /* Commands */
 #define TI_GET_VERSION                  0x01
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index bd3fa7ff15b1..3873660d8217 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -247,96 +247,66 @@ static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
         return retval;
 }
 
-static int serial_open(struct tty_struct *tty, struct file *filp)
+static int serial_activate(struct tty_port *tport, struct tty_struct *tty)
 {
-        struct usb_serial_port *port = tty->driver_data;
+        struct usb_serial_port *port =
+                container_of(tport, struct usb_serial_port, port);
         struct usb_serial *serial = port->serial;
         int retval;
 
-        dbg("%s - port %d", __func__, port->number);
-
-        spin_lock_irq(&port->port.lock);
-        if (!tty_hung_up_p(filp))
-                ++port->port.count;
-        spin_unlock_irq(&port->port.lock);
-        tty_port_tty_set(&port->port, tty);
+        mutex_lock(&serial->disc_mutex);
+        if (serial->disconnected)
+                retval = -ENODEV;
+        else
+                retval = port->serial->type->open(tty, port);
+        mutex_unlock(&serial->disc_mutex);
+        return retval;
+}
 
-        /* Do the device-specific open only if the hardware isn't
-         * already initialized.
-         */
-        if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
-                if (mutex_lock_interruptible(&port->mutex))
-                        return -ERESTARTSYS;
-                mutex_lock(&serial->disc_mutex);
-                if (serial->disconnected)
-                        retval = -ENODEV;
-                else
-                        retval = port->serial->type->open(tty, port);
-                mutex_unlock(&serial->disc_mutex);
-                mutex_unlock(&port->mutex);
-                if (retval)
-                        return retval;
-                set_bit(ASYNCB_INITIALIZED, &port->port.flags);
-        }
+static int serial_open(struct tty_struct *tty, struct file *filp)
+{
+        struct usb_serial_port *port = tty->driver_data;
 
-        /* Now do the correct tty layer semantics */
-        retval = tty_port_block_til_ready(&port->port, tty, filp);
-        return retval;
+        dbg("%s - port %d", __func__, port->number);
+        return tty_port_open(&port->port, tty, filp);
 }
 
 /**
  * serial_down - shut down hardware
- * @port: port to shut down
+ * @tport: tty port to shut down
  *
  * Shut down a USB serial port unless it is the console.  We never
- * shut down the console hardware as it will always be in use.
+ * shut down the console hardware as it will always be in use. Serialized
+ * against activate by the tport mutex and kept to matching open/close pairs
+ * of calls by the ASYNCB_INITIALIZED flag.
  */
-static void serial_down(struct usb_serial_port *port)
+static void serial_down(struct tty_port *tport)
 {
+        struct usb_serial_port *port =
+                container_of(tport, struct usb_serial_port, port);
         struct usb_serial_driver *drv = port->serial->type;
-
         /*
          * The console is magical.  Do not hang up the console hardware
          * or there will be tears.
          */
         if (port->console)
                 return;
-
-        /* Don't call the close method if the hardware hasn't been
-         * initialized.
-         */
-        if (!test_and_clear_bit(ASYNCB_INITIALIZED, &port->port.flags))
-                return;
-
-        mutex_lock(&port->mutex);
         if (drv->close)
                 drv->close(port);
-        mutex_unlock(&port->mutex);
 }
 
 static void serial_hangup(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
-
         dbg("%s - port %d", __func__, port->number);
-
-        serial_down(port);
         tty_port_hangup(&port->port);
 }
 
 static void serial_close(struct tty_struct *tty, struct file *filp)
 {
         struct usb_serial_port *port = tty->driver_data;
-
         dbg("%s - port %d", __func__, port->number);
-
-        if (tty_hung_up_p(filp))
-                return;
-        if (tty_port_close_start(&port->port, tty, filp) == 0)
-                return;
-        serial_down(port);
-        tty_port_close_end(&port->port, tty);
-        tty_port_tty_set(&port->port, NULL);
+        tty_port_close(&port->port, tty, filp);
 }
 
 /**
@@ -388,10 +358,6 @@ static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 
         dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
 
-        /* count is managed under the mutex lock for the tty so cannot
-           drop to zero until after the last close completes */
-        WARN_ON(!port->port.count);
-
         /* pass on to the driver specific version of this function */
         retval = port->serial->type->write(tty, port, buf, count);
 
@@ -403,7 +369,6 @@ static int serial_write_room(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
-        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function */
         return port->serial->type->write_room(tty);
 }
@@ -411,7 +376,7 @@ static int serial_write_room(struct tty_struct *tty)
 static int serial_chars_in_buffer(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
-        dbg("%s = port %d", __func__, port->number);
+        dbg("%s - port %d", __func__, port->number);
 
         /* if the device was unplugged then any remaining characters
            fell out of the connector ;) */
@@ -426,7 +391,6 @@ static void serial_throttle(struct tty_struct *tty)
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function */
         if (port->serial->type->throttle)
                 port->serial->type->throttle(tty);
@@ -437,7 +401,6 @@ static void serial_unthrottle(struct tty_struct *tty)
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function */
         if (port->serial->type->unthrottle)
                 port->serial->type->unthrottle(tty);
@@ -451,8 +414,6 @@ static int serial_ioctl(struct tty_struct *tty, struct file *file,
 
         dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 
-        WARN_ON(!port->port.count);
-
         /* pass on to the driver specific version of this function
            if it is available */
         if (port->serial->type->ioctl) {
@@ -467,7 +428,6 @@ static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
         struct usb_serial_port *port = tty->driver_data;
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function
            if it is available */
         if (port->serial->type->set_termios)
@@ -482,7 +442,6 @@ static int serial_break(struct tty_struct *tty, int break_state)
 
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->port.count);
         /* pass on to the driver specific version of this function
            if it is available */
         if (port->serial->type->break_ctl)
@@ -543,7 +502,6 @@ static int serial_tiocmget(struct tty_struct *tty, struct file *file)
 
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->port.count);
         if (port->serial->type->tiocmget)
                 return port->serial->type->tiocmget(tty, file);
         return -EINVAL;
@@ -556,7 +514,6 @@ static int serial_tiocmset(struct tty_struct *tty, struct file *file,
 
         dbg("%s - port %d", __func__, port->number);
 
-        WARN_ON(!port->port.count);
         if (port->serial->type->tiocmset)
                 return port->serial->type->tiocmset(tty, file, set, clear);
         return -EINVAL;
@@ -625,8 +582,7 @@ static void port_release(struct device *dev)
         usb_free_urb(port->write_urb);
         usb_free_urb(port->interrupt_in_urb);
         usb_free_urb(port->interrupt_out_urb);
-        if (!IS_ERR(port->write_fifo) && port->write_fifo)
-                kfifo_free(port->write_fifo);
+        kfifo_free(&port->write_fifo);
         kfree(port->bulk_in_buffer);
         kfree(port->bulk_out_buffer);
         kfree(port->interrupt_in_buffer);
@@ -725,6 +681,8 @@ static void serial_dtr_rts(struct tty_port *port, int on)
 static const struct tty_port_operations serial_port_ops = {
         .carrier_raised = serial_carrier_raised,
         .dtr_rts = serial_dtr_rts,
+        .activate = serial_activate,
+        .shutdown = serial_down,
 };
 
 int usb_serial_probe(struct usb_interface *interface,
@@ -923,7 +881,8 @@ int usb_serial_probe(struct usb_interface *interface,
                 port->port.ops = &serial_port_ops;
                 port->serial = serial;
                 spin_lock_init(&port->lock);
-                mutex_init(&port->mutex);
+                /* Keep this for private driver use for the moment but
+                   should probably go away */
                 INIT_WORK(&port->work, usb_serial_port_work);
                 serial->port[i] = port;
                 port->dev.parent = &interface->dev;
@@ -966,9 +925,7 @@ int usb_serial_probe(struct usb_interface *interface,
                         dev_err(&interface->dev, "No free urbs available\n");
                         goto probe_error;
                 }
-                port->write_fifo = kfifo_alloc(PAGE_SIZE, GFP_KERNEL,
-                        &port->lock);
-                if (IS_ERR(port->write_fifo))
+                if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
                         goto probe_error;
                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
                 port->bulk_out_size = buffer_size;
diff --git a/drivers/usb/serial/usb_debug.c b/drivers/usb/serial/usb_debug.c
index 7b5bfc4edd3d..28026b47344a 100644
--- a/drivers/usb/serial/usb_debug.c
+++ b/drivers/usb/serial/usb_debug.c
@@ -8,6 +8,7 @@
  *      2 as published by the Free Software Foundation.
  */
 
+#include <linux/gfp.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/tty.h>
@@ -29,7 +30,7 @@ static char USB_DEBUG_BRK[USB_DEBUG_BRK_SIZE] = {
         0xff,
 };
 
-static struct usb_device_id id_table [] = {
+static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x0525, 0x127a) },
         { },
 };
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index ad1f9232292d..094942707c7d 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -368,7 +368,7 @@ static int visor_write(struct tty_struct *tty, struct usb_serial_port *port,
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->outstanding_urbs > URB_UPPER_LIMIT) {
                 spin_unlock_irqrestore(&priv->lock, flags);
-                dbg("%s - write limit hit\n", __func__);
+                dbg("%s - write limit hit", __func__);
                 return 0;
         }
         priv->outstanding_urbs++;
@@ -446,7 +446,7 @@ static int visor_write_room(struct tty_struct *tty)
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->outstanding_urbs > URB_UPPER_LIMIT * 2 / 3) {
                 spin_unlock_irqrestore(&priv->lock, flags);
-                dbg("%s - write limit hit\n", __func__);
+                dbg("%s - write limit hit", __func__);
                 return 0;
         }
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -503,13 +503,9 @@ static void visor_read_bulk_callback(struct urb *urb)
         if (urb->actual_length) {
                 tty = tty_port_tty_get(&port->port);
                 if (tty) {
-                        available_room = tty_buffer_request_room(tty,
-                                                        urb->actual_length);
-                        if (available_room) {
-                                tty_insert_flip_string(tty, data,
-                                                        available_room);
-                                tty_flip_buffer_push(tty);
-                        }
+                        tty_insert_flip_string(tty, data,
+                                                urb->actual_length);
+                        tty_flip_buffer_push(tty);
                         tty_kref_put(tty);
                 }
                 spin_lock(&priv->lock);
@@ -807,10 +803,14 @@ static int clie_3_5_startup(struct usb_serial *serial)
 {
         struct device *dev = &serial->dev->dev;
         int result;
-        u8 data;
+        u8 *data;
 
         dbg("%s", __func__);
 
+        data = kmalloc(1, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
         /*
          * Note that PEG-300 series devices expect the following two calls.
          */
@@ -818,36 +818,42 @@ static int clie_3_5_startup(struct usb_serial *serial)
         /* get the config number */
         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
                                   USB_REQ_GET_CONFIGURATION, USB_DIR_IN,
-                                  0, 0, &data, 1, 3000);
+                                  0, 0, data, 1, 3000);
         if (result < 0) {
                 dev_err(dev, "%s: get config number failed: %d\n",
                                                         __func__, result);
-                return result;
+                goto out;
         }
         if (result != 1) {
                 dev_err(dev, "%s: get config number bad return length: %d\n",
                                                         __func__, result);
-                return -EIO;
+                result = -EIO;
+                goto out;
         }
 
         /* get the interface number */
         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
                                   USB_REQ_GET_INTERFACE,
                                   USB_DIR_IN | USB_RECIP_INTERFACE,
-                                  0, 0, &data, 1, 3000);
+                                  0, 0, data, 1, 3000);
         if (result < 0) {
                 dev_err(dev, "%s: get interface number failed: %d\n",
                                                         __func__, result);
-                return result;
+                goto out;
         }
         if (result != 1) {
                 dev_err(dev,
                         "%s: get interface number bad return length: %d\n",
                                                         __func__, result);
-                return -EIO;
+                result = -EIO;
+                goto out;
         }
 
-        return generic_startup(serial);
+        result = generic_startup(serial);
+out:
+        kfree(data);
+
+        return result;
 }
 
 static int treo_attach(struct usb_serial *serial)
diff --git a/drivers/usb/serial/vivopay-serial.c b/drivers/usb/serial/vivopay-serial.c
new file mode 100644
index 000000000000..f719d00972fc
--- /dev/null
+++ b/drivers/usb/serial/vivopay-serial.c
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2001-2005 Greg Kroah-Hartman (greg@kroah.com)
+ * Copyright (C) 2009 Outpost Embedded, LLC
+ */
+
+#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>
+
+
+#define DRIVER_VERSION "v1.0"
+#define DRIVER_DESC "ViVOpay USB Serial Driver"
+
+#define VIVOPAY_VENDOR_ID 0x1d5f
+
+
+static struct usb_device_id id_table [] = {
+        /* ViVOpay 8800 */
+        { USB_DEVICE(VIVOPAY_VENDOR_ID, 0x1004) },
+        { },
+};
+
+MODULE_DEVICE_TABLE(usb, id_table);
+
+static struct usb_driver vivopay_serial_driver = {
+        .name =                 "vivopay-serial",
+        .probe =                usb_serial_probe,
+        .disconnect =           usb_serial_disconnect,
+        .id_table =             id_table,
+        .no_dynamic_id =        1,
+};
+
+static struct usb_serial_driver vivopay_serial_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "vivopay-serial",
+        },
+        .id_table =             id_table,
+        .usb_driver =           &vivopay_serial_driver,
+        .num_ports =            1,
+};
+
+static int __init vivopay_serial_init(void)
+{
+        int retval;
+        retval = usb_serial_register(&vivopay_serial_device);
+        if (retval)
+                goto failed_usb_serial_register;
+        retval = usb_register(&vivopay_serial_driver);
+        if (retval)
+                goto failed_usb_register;
+        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
+            DRIVER_DESC "\n");
+        return 0;
+failed_usb_register:
+        usb_serial_deregister(&vivopay_serial_device);
+failed_usb_serial_register:
+        return retval;
+}
+
+static void __exit vivopay_serial_exit(void)
+{
+        usb_deregister(&vivopay_serial_driver);
+        usb_serial_deregister(&vivopay_serial_device);
+}
+
+module_init(vivopay_serial_init);
+module_exit(vivopay_serial_exit);
+
+MODULE_AUTHOR("Forest Bond <forest.bond@outpostembedded.com>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index 1093d2eb046a..12ed8209ca72 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -111,17 +111,17 @@ static int debug;
    separate ID tables, and then a third table that combines them
    just for the purpose of exporting the autoloading information.
 */
-static struct usb_device_id id_table_std [] = {
+static const struct usb_device_id id_table_std[] = {
         { USB_DEVICE(CONNECT_TECH_VENDOR_ID, CONNECT_TECH_WHITE_HEAT_ID) },
         { }                                             /* Terminating entry */
 };
 
-static struct usb_device_id id_table_prerenumeration [] = {
+static const struct usb_device_id id_table_prerenumeration[] = {
         { USB_DEVICE(CONNECT_TECH_VENDOR_ID, CONNECT_TECH_FAKE_WHITE_HEAT_ID) },
         { }                                             /* Terminating entry */
 };
 
-static struct usb_device_id id_table_combined [] = {
+static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(CONNECT_TECH_VENDOR_ID, CONNECT_TECH_WHITE_HEAT_ID) },
         { USB_DEVICE(CONNECT_TECH_VENDOR_ID, CONNECT_TECH_FAKE_WHITE_HEAT_ID) },
         { }                                             /* Terminating entry */
@@ -1492,21 +1492,9 @@ static void rx_data_softint(struct work_struct *work)
                 wrap = list_entry(tmp, struct whiteheat_urb_wrap, list);
                 urb = wrap->urb;
 
-                if (tty && urb->actual_length) {
-                        int len = tty_buffer_request_room(tty,
-                                                        urb->actual_length);
-                        /* This stuff can go away now I suspect */
-                        if (unlikely(len < urb->actual_length)) {
-                                spin_lock_irqsave(&info->lock, flags);
-                                list_add(tmp, &info->rx_urb_q);
-                                spin_unlock_irqrestore(&info->lock, flags);
-                                tty_flip_buffer_push(tty);
-                                schedule_work(&info->rx_work);
-                                goto out;
-                        }
-                        tty_insert_flip_string(tty, urb->transfer_buffer, len);
-                        sent += len;
-                }
+                if (tty && urb->actual_length)
+                        sent += tty_insert_flip_string(tty,
+                                urb->transfer_buffer, urb->actual_length);
 
                 urb->dev = port->serial->dev;
                 result = usb_submit_urb(urb, GFP_ATOMIC);
diff --git a/drivers/usb/storage/alauda.c b/drivers/usb/storage/alauda.c
index 67edc65acb8e..42d0eaed4a01 100644
--- a/drivers/usb/storage/alauda.c
+++ b/drivers/usb/storage/alauda.c
@@ -32,6 +32,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
diff --git a/drivers/usb/storage/karma.c b/drivers/usb/storage/karma.c
index 7953d93a7739..ba1b78906880 100644
--- a/drivers/usb/storage/karma.c
+++ b/drivers/usb/storage/karma.c
@@ -19,6 +19,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
diff --git a/drivers/usb/storage/onetouch.c b/drivers/usb/storage/onetouch.c
index 80e65f29921c..198bb3ed95b2 100644
--- a/drivers/usb/storage/onetouch.c
+++ b/drivers/usb/storage/onetouch.c
@@ -202,7 +202,7 @@ static int onetouch_connect_input(struct us_data *ss)
                 goto fail1;
 
         onetouch->data = usb_buffer_alloc(udev, ONETOUCH_PKT_LEN,
-                                          GFP_ATOMIC, &onetouch->data_dma);
+                                          GFP_KERNEL, &onetouch->data_dma);
         if (!onetouch->data)
                 goto fail1;
 
diff --git a/drivers/usb/storage/option_ms.c b/drivers/usb/storage/option_ms.c
index 773a5cd38c5a..89460181d122 100644
--- a/drivers/usb/storage/option_ms.c
+++ b/drivers/usb/storage/option_ms.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/usb.h>
+#include <linux/slab.h>
 
 #include "usb.h"
 #include "transport.h"
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index cfa26d56ce60..d8d98cfecada 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -43,7 +43,6 @@
  * 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 
@@ -73,7 +72,8 @@
 
 static const char* host_info(struct Scsi_Host *host)
 {
-        return "SCSI emulation for USB Mass Storage devices";
+        struct us_data *us = host_to_us(host);
+        return us->scsi_name;
 }
 
 static int slave_alloc (struct scsi_device *sdev)
@@ -132,15 +132,15 @@ static int slave_configure(struct scsi_device *sdev)
 
                 if (us->fflags & US_FL_MAX_SECTORS_MIN)
                         max_sectors = PAGE_CACHE_SIZE >> 9;
-                if (queue_max_sectors(sdev->request_queue) > max_sectors)
-                        blk_queue_max_sectors(sdev->request_queue,
+                if (queue_max_hw_sectors(sdev->request_queue) > max_sectors)
+                        blk_queue_max_hw_sectors(sdev->request_queue,
                                               max_sectors);
         } else if (sdev->type == TYPE_TAPE) {
                 /* Tapes need much higher max_sector limits, so just
                  * raise it to the maximum possible (4 GB / 512) and
                  * let the queue segment size sort out the real limit.
                  */
-                blk_queue_max_sectors(sdev->request_queue, 0x7FFFFF);
+                blk_queue_max_hw_sectors(sdev->request_queue, 0x7FFFFF);
         }
 
         /* Some USB host controllers can't do DMA; they have to use PIO.
@@ -483,7 +483,7 @@ static ssize_t show_max_sectors(struct device *dev, struct device_attribute *att
 {
         struct scsi_device *sdev = to_scsi_device(dev);
 
-        return sprintf(buf, "%u\n", queue_max_sectors(sdev->request_queue));
+        return sprintf(buf, "%u\n", queue_max_hw_sectors(sdev->request_queue));
 }
 
 /* Input routine for the sysfs max_sectors file */
@@ -493,9 +493,9 @@ static ssize_t store_max_sectors(struct device *dev, struct device_attribute *at
         struct scsi_device *sdev = to_scsi_device(dev);
         unsigned short ms;
 
-        if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
-                blk_queue_max_sectors(sdev->request_queue, ms);
-                return strlen(buf);
+        if (sscanf(buf, "%hu", &ms) > 0) {
+                blk_queue_max_hw_sectors(sdev->request_queue, ms);
+                return count;
         }
         return -EINVAL; 
 }
@@ -538,7 +538,7 @@ struct scsi_host_template usb_stor_host_template = {
         .slave_configure =              slave_configure,
 
         /* lots of sg segments can be handled */
-        .sg_tablesize =                 SG_ALL,
+        .sg_tablesize =                 SCSI_MAX_SG_CHAIN_SEGMENTS,
 
         /* limit the total size of a transfer to 120 KB */
         .max_sectors =                  240,
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index b62a28814ebe..bd3f415893d8 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -1628,10 +1628,10 @@ static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us)
                 return USB_STOR_TRANSPORT_ERROR;
         }
 
-        if ( (result = usbat_multiple_write(us, 
-                        registers, data, 7)) != USB_STOR_TRANSPORT_GOOD) {
+        result = usbat_multiple_write(us, registers, data, 7);
+
+        if (result != USB_STOR_TRANSPORT_GOOD)
                 return result;
-        }
 
         /*
          * Write the 12-byte command header.
@@ -1643,12 +1643,11 @@ static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us)
          * AT SPEED 4 IS UNRELIABLE!!!
          */
 
-        if ((result = usbat_write_block(us,
-                        USBAT_ATA, srb->cmnd, 12,
-                                (srb->cmnd[0]==GPCMD_BLANK ? 75 : 10), 0) !=
-                             USB_STOR_TRANSPORT_GOOD)) {
+        result = usbat_write_block(us, USBAT_ATA, srb->cmnd, 12,
+                                   srb->cmnd[0] == GPCMD_BLANK ? 75 : 10, 0);
+
+        if (result != USB_STOR_TRANSPORT_GOOD)
                 return result;
-        }
 
         /* If there is response data to be read in then do it here. */
 
diff --git a/drivers/usb/storage/sierra_ms.c b/drivers/usb/storage/sierra_ms.c
index 4395c4100ec2..57fc2f532cab 100644
--- a/drivers/usb/storage/sierra_ms.c
+++ b/drivers/usb/storage/sierra_ms.c
@@ -3,6 +3,7 @@
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <linux/usb.h>
+#include <linux/slab.h>
 
 #include "usb.h"
 #include "transport.h"
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 589f6b4404f0..f253edec3bb8 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -44,8 +44,10 @@
  */
 
 #include <linux/sched.h>
+#include <linux/gfp.h>
 #include <linux/errno.h>
-#include <linux/slab.h>
+
+#include <linux/usb/quirks.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_eh.h>
@@ -666,10 +668,11 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
          * to wait for at least one CHECK_CONDITION to determine
          * SANE_SENSE support
          */
-        if ((srb->cmnd[0] == ATA_16 || srb->cmnd[0] == ATA_12) &&
+        if (unlikely((srb->cmnd[0] == ATA_16 || srb->cmnd[0] == ATA_12) &&
             result == USB_STOR_TRANSPORT_GOOD &&
             !(us->fflags & US_FL_SANE_SENSE) &&
-            !(srb->cmnd[2] & 0x20)) {
+            !(us->fflags & US_FL_BAD_SENSE) &&
+            !(srb->cmnd[2] & 0x20))) {
                 US_DEBUGP("-- SAT supported, increasing auto-sense\n");
                 us->fflags |= US_FL_SANE_SENSE;
         }
@@ -718,6 +721,12 @@ Retry_Sense:
                 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
                         US_DEBUGP("-- auto-sense aborted\n");
                         srb->result = DID_ABORT << 16;
+
+                        /* If SANE_SENSE caused this problem, disable it */
+                        if (sense_size != US_SENSE_SIZE) {
+                                us->fflags &= ~US_FL_SANE_SENSE;
+                                us->fflags |= US_FL_BAD_SENSE;
+                        }
                         goto Handle_Errors;
                 }
 
@@ -727,10 +736,11 @@ Retry_Sense:
                  * (small) sense request. This fixes some USB GSM modems
                  */
                 if (temp_result == USB_STOR_TRANSPORT_FAILED &&
-                    (us->fflags & US_FL_SANE_SENSE) &&
-                    sense_size != US_SENSE_SIZE) {
+                                sense_size != US_SENSE_SIZE) {
                         US_DEBUGP("-- auto-sense failure, retry small sense\n");
                         sense_size = US_SENSE_SIZE;
+                        us->fflags &= ~US_FL_SANE_SENSE;
+                        us->fflags |= US_FL_BAD_SENSE;
                         goto Retry_Sense;
                 }
 
@@ -754,6 +764,7 @@ Retry_Sense:
                  */
                 if (srb->sense_buffer[7] > (US_SENSE_SIZE - 8) &&
                     !(us->fflags & US_FL_SANE_SENSE) &&
+                    !(us->fflags & US_FL_BAD_SENSE) &&
                     (srb->sense_buffer[0] & 0x7C) == 0x70) {
                         US_DEBUGP("-- SANE_SENSE support enabled\n");
                         us->fflags |= US_FL_SANE_SENSE;
@@ -1288,6 +1299,10 @@ int usb_stor_port_reset(struct us_data *us)
 {
         int result;
 
+        /*for these devices we must use the class specific method */
+        if (us->pusb_dev->quirks & USB_QUIRK_RESET_MORPHS)
+                return -EPERM;
+
         result = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf);
         if (result < 0)
                 US_DEBUGP("unable to lock device for reset: %d\n", result);
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index d4f034ebaa8a..ccf1dbbb87ef 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -374,6 +374,15 @@ UNUSUAL_DEV(  0x04ce, 0x0002, 0x0074, 0x0074,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY),
 
+/* Reported by Ondrej Zary <linux@rainbow-software.org>
+ * The device reports one sector more and breaks when that sector is accessed
+ */
+UNUSUAL_DEV(  0x04ce, 0x0002, 0x026c, 0x026c,
+                "ScanLogic",
+                "SL11R-IDE",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY),
+
 /* Reported by Kriston Fincher <kriston@airmail.net>
  * Patch submitted by Sean Millichamp <sean@bruenor.org>
  * This is to support the Panasonic PalmCam PV-SD4090
@@ -818,6 +827,13 @@ UNUSUAL_DEV( 0x066f, 0x8000, 0x0001, 0x0001,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
+/* Reported by Daniel Kukula <daniel.kuku@gmail.com> */
+UNUSUAL_DEV( 0x067b, 0x1063, 0x0100, 0x0100,
+                "Prolific Technology, Inc.",
+                "Prolific Storage Gadget",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_BAD_SENSE ),
+
 /* Reported by Rogerio Brito <rbrito@ime.usp.br> */
 UNUSUAL_DEV( 0x067b, 0x2317, 0x0001, 0x001,
                 "Prolific Technology, Inc.",
@@ -934,7 +950,7 @@ UNUSUAL_DEV(  0x07ab, 0xfccd, 0x0000, 0x9999,
 UNUSUAL_DEV(  0x07af, 0x0004, 0x0100, 0x0133,
                 "Microtech",
                 "USB-SCSI-DB25",
-                US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init,
+                US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ), 
 
 UNUSUAL_DEV(  0x07af, 0x0005, 0x0100, 0x0100,
@@ -1140,8 +1156,8 @@ UNUSUAL_DEV( 0x0af0, 0x7401, 0x0000, 0x0000,
                 0 ),
 
 /* Reported by Jan Dumon <j.dumon@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
+ * These devices (wrongly) have a vendor-specific device descriptor.
+ * These entries are needed so usb-storage can bind to their mass-storage
  * interface as an interface driver */
 UNUSUAL_DEV( 0x0af0, 0x7501, 0x0000, 0x0000,
                 "Option",
@@ -1149,6 +1165,90 @@ UNUSUAL_DEV( 0x0af0, 0x7501, 0x0000, 0x0000,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 0 ),
 
+UNUSUAL_DEV( 0x0af0, 0x7701, 0x0000, 0x0000,
+                "Option",
+                "GI 0451 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0x7706, 0x0000, 0x0000,
+                "Option",
+                "GI 0451 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0x7901, 0x0000, 0x0000,
+                "Option",
+                "GI 0452 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0x7A01, 0x0000, 0x0000,
+                "Option",
+                "GI 0461 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0x7A05, 0x0000, 0x0000,
+                "Option",
+                "GI 0461 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0x8300, 0x0000, 0x0000,
+                "Option",
+                "GI 033x SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0x8302, 0x0000, 0x0000,
+                "Option",
+                "GI 033x SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0x8304, 0x0000, 0x0000,
+                "Option",
+                "GI 033x SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0xc100, 0x0000, 0x0000,
+                "Option",
+                "GI 070x SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0xd057, 0x0000, 0x0000,
+                "Option",
+                "GI 1505 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0xd058, 0x0000, 0x0000,
+                "Option",
+                "GI 1509 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0xd157, 0x0000, 0x0000,
+                "Option",
+                "GI 1515 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0xd257, 0x0000, 0x0000,
+                "Option",
+                "GI 1215 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
+UNUSUAL_DEV( 0x0af0, 0xd357, 0x0000, 0x0000,
+                "Option",
+                "GI 1505 SD-Card",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                0 ),
+
 /* Reported by Ben Efros <ben@pc-doctor.com> */
 UNUSUAL_DEV( 0x0bc2, 0x3010, 0x0000, 0x0000,
                 "Seagate",
@@ -1289,20 +1389,6 @@ UNUSUAL_DEV(  0x0f19, 0x0105, 0x0100, 0x0100,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
-/* Jeremy Katz <katzj@redhat.com>:
- * The Blackberry Pearl can run in two modes; a usb-storage only mode
- * and a mode that allows access via mass storage and to its database.
- * The berry_charge module will set the device to dual mode and thus we
- * should ignore its native mode if that module is built
- */
-#ifdef CONFIG_USB_BERRY_CHARGE
-UNUSUAL_DEV(  0x0fca, 0x0006, 0x0001, 0x0001,
-                "RIM",
-                "Blackberry Pearl",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_IGNORE_DEVICE ),
-#endif
-
 /* Reported by Michael Stattmann <michael@stattmann.com> */
 UNUSUAL_DEV(  0x0fce, 0xd008, 0x0000, 0x0000,
                 "Sony Ericsson",
@@ -1800,13 +1886,6 @@ 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 ),
-
 /* Reported by Frederic Marchal <frederic.marchal@wowcompany.com>
  * Mio Moov 330
  */
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 8060b85fe1a3..bbeeb92a2131 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -45,6 +45,10 @@
  * 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#ifdef CONFIG_USB_STORAGE_DEBUG
+#define DEBUG
+#endif
+
 #include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/freezer.h>
@@ -74,7 +78,7 @@ MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
 MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
 MODULE_LICENSE("GPL");
 
-static unsigned int delay_use = 5;
+static unsigned int delay_use = 1;
 module_param(delay_use, uint, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
 
@@ -228,6 +232,7 @@ void fill_inquiry_response(struct us_data *us, unsigned char *data,
         if (data_len<36) // You lose.
                 return;
 
+        memset(data+8, ' ', 28);
         if(data[0]&0x20) { /* USB device currently not connected. Return
                               peripheral qualifier 001b ("...however, the
                               physical device is not currently connected
@@ -237,15 +242,15 @@ void fill_inquiry_response(struct us_data *us, unsigned char *data,
                               device, it may return zeros or ASCII spaces 
                               (20h) in those fields until the data is
                               available from the device."). */
-                memset(data+8,0,28);
         } else {
                 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
-                memcpy(data+8, us->unusual_dev->vendorName, 
-                        strlen(us->unusual_dev->vendorName) > 8 ? 8 :
-                        strlen(us->unusual_dev->vendorName));
-                memcpy(data+16, us->unusual_dev->productName, 
-                        strlen(us->unusual_dev->productName) > 16 ? 16 :
-                        strlen(us->unusual_dev->productName));
+                int n;
+
+                n = strlen(us->unusual_dev->vendorName);
+                memcpy(data+8, us->unusual_dev->vendorName, min(8, n));
+                n = strlen(us->unusual_dev->productName);
+                memcpy(data+16, us->unusual_dev->productName, min(16, n));
+
                 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
                 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
                 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
@@ -429,7 +434,8 @@ static void adjust_quirks(struct us_data *us)
         u16 vid = le16_to_cpu(us->pusb_dev->descriptor.idVendor);
         u16 pid = le16_to_cpu(us->pusb_dev->descriptor.idProduct);
         unsigned f = 0;
-        unsigned int mask = (US_FL_SANE_SENSE | US_FL_FIX_CAPACITY |
+        unsigned int mask = (US_FL_SANE_SENSE | US_FL_BAD_SENSE |
+                        US_FL_FIX_CAPACITY |
                         US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE |
                         US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
                         US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
@@ -459,6 +465,9 @@ static void adjust_quirks(struct us_data *us)
                 case 'a':
                         f |= US_FL_SANE_SENSE;
                         break;
+                case 'b':
+                        f |= US_FL_BAD_SENSE;
+                        break;
                 case 'c':
                         f |= US_FL_FIX_CAPACITY;
                         break;
@@ -808,14 +817,13 @@ static int usb_stor_scan_thread(void * __us)
 {
         struct us_data *us = (struct us_data *)__us;
 
-        printk(KERN_DEBUG
-                "usb-storage: device found at %d\n", us->pusb_dev->devnum);
+        dev_dbg(&us->pusb_intf->dev, "device found\n");
 
         set_freezable();
         /* Wait for the timeout to expire or for a disconnect */
         if (delay_use > 0) {
-                printk(KERN_DEBUG "usb-storage: waiting for device "
-                                "to settle before scanning\n");
+                dev_dbg(&us->pusb_intf->dev, "waiting for device to settle "
+                                "before scanning\n");
                 wait_event_freezable_timeout(us->delay_wait,
                                 test_bit(US_FLIDX_DONT_SCAN, &us->dflags),
                                 delay_use * HZ);
@@ -832,7 +840,7 @@ static int usb_stor_scan_thread(void * __us)
                         mutex_unlock(&us->dev_mutex);
                 }
                 scsi_scan_host(us_to_host(us));
-                printk(KERN_DEBUG "usb-storage: device scan complete\n");
+                dev_dbg(&us->pusb_intf->dev, "scan complete\n");
 
                 /* Should we unbind if no devices were detected? */
         }
@@ -840,6 +848,15 @@ static int usb_stor_scan_thread(void * __us)
         complete_and_exit(&us->scanning_done, 0);
 }
 
+static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf)
+{
+        struct usb_device *usb_dev = interface_to_usbdev(intf);
+
+        if (usb_dev->bus->sg_tablesize) {
+                return usb_dev->bus->sg_tablesize;
+        }
+        return SG_ALL;
+}
 
 /* First part of general USB mass-storage probing */
 int usb_stor_probe1(struct us_data **pus,
@@ -868,6 +885,7 @@ int usb_stor_probe1(struct us_data **pus,
          * Allow 16-byte CDBs and thus > 2TB
          */
         host->max_cmd_len = 16;
+        host->sg_tablesize = usb_stor_sg_tablesize(intf);
         *pus = us = host_to_us(host);
         memset(us, 0, sizeof(struct us_data));
         mutex_init(&(us->dev_mutex));
@@ -929,6 +947,8 @@ int usb_stor_probe2(struct us_data *us)
         result = usb_stor_acquire_resources(us);
         if (result)
                 goto BadDevice;
+        snprintf(us->scsi_name, sizeof(us->scsi_name), "usb-storage %s",
+                                        dev_name(&us->pusb_intf->dev));
         result = scsi_add_host(us_to_host(us), &us->pusb_intf->dev);
         if (result) {
                 printk(KERN_WARNING USB_STORAGE
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index 2609efb2bd7e..69717134231b 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -132,6 +132,7 @@ struct us_data {
         /* SCSI interfaces */
         struct scsi_cmnd        *srb;            /* current srb         */
         unsigned int            tag;             /* current dCBWTag     */
+        char                    scsi_name[32];   /* scsi_host name      */
 
         /* control and bulk communications data */
         struct urb              *current_urb;    /* USB requests         */
diff --git a/drivers/usb/usb-skeleton.c b/drivers/usb/usb-skeleton.c
index b62f2bc064f6..61522787f39c 100644
--- a/drivers/usb/usb-skeleton.c
+++ b/drivers/usb/usb-skeleton.c
@@ -28,7 +28,7 @@
 #define USB_SKEL_PRODUCT_ID     0xfff0
 
 /* table of devices that work with this driver */
-static struct usb_device_id skel_table[] = {
+static const struct usb_device_id skel_table[] = {
         { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
@@ -358,7 +358,7 @@ retry:
                 rv = skel_do_read_io(dev, count);
                 if (rv < 0)
                         goto exit;
-                else if (!file->f_flags & O_NONBLOCK)
+                else if (!(file->f_flags & O_NONBLOCK))
                         goto retry;
                 rv = -EAGAIN;
         }
@@ -411,7 +411,7 @@ static ssize_t skel_write(struct file *file, const char *user_buffer,
          * limit the number of URBs in flight to stop a user from using up all
          * RAM
          */
-        if (!file->f_flags & O_NONBLOCK) {
+        if (!(file->f_flags & O_NONBLOCK)) {
                 if (down_interruptible(&dev->limit_sem)) {
                         retval = -ERESTARTSYS;
                         goto exit;
diff --git a/drivers/usb/wusbcore/cbaf.c b/drivers/usb/wusbcore/cbaf.c
index 25eae405f622..c0c5665e60a9 100644
--- a/drivers/usb/wusbcore/cbaf.c
+++ b/drivers/usb/wusbcore/cbaf.c
@@ -92,6 +92,7 @@
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/uwb.h>
 #include <linux/usb/wusb.h>
@@ -641,7 +642,7 @@ static void cbaf_disconnect(struct usb_interface *iface)
         kzfree(cbaf);
 }
 
-static struct usb_device_id cbaf_id_table[] = {
+static const struct usb_device_id cbaf_id_table[] = {
         { USB_INTERFACE_INFO(0xef, 0x03, 0x01), },
         { },
 };
diff --git a/drivers/usb/wusbcore/crypto.c b/drivers/usb/wusbcore/crypto.c
index 9ec7fd5da489..827c87f10cc5 100644
--- a/drivers/usb/wusbcore/crypto.c
+++ b/drivers/usb/wusbcore/crypto.c
@@ -49,6 +49,7 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/uwb.h>
+#include <linux/slab.h>
 #include <linux/usb/wusb.h>
 #include <linux/scatterlist.h>
 
@@ -111,7 +112,7 @@ struct aes_ccm_b1 {
  *
  * CCM uses Ax blocks to generate a keystream with which the MIC and
  * the message's payload are encoded. A0 always encrypts/decrypts the
- * MIC. Ax (x>0) are used for the sucesive payload blocks.
+ * MIC. Ax (x>0) are used for the successive payload blocks.
  *
  * The x is the counter, and is increased for each block.
  */
diff --git a/drivers/usb/wusbcore/devconnect.c b/drivers/usb/wusbcore/devconnect.c
index 4ac4300a3f9a..7ec24e46b34b 100644
--- a/drivers/usb/wusbcore/devconnect.c
+++ b/drivers/usb/wusbcore/devconnect.c
@@ -88,6 +88,7 @@
 
 #include <linux/jiffies.h>
 #include <linux/ctype.h>
+#include <linux/slab.h>
 #include <linux/workqueue.h>
 #include "wusbhc.h"
 
@@ -119,10 +120,12 @@ static struct wusb_dev *wusb_dev_alloc(struct wusbhc *wusbhc)
         urb = usb_alloc_urb(0, GFP_KERNEL);
         if (urb == NULL)
                 goto err;
+        wusb_dev->set_gtk_urb = urb;
 
-        req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
+        req = kmalloc(sizeof(*req), GFP_KERNEL);
         if (req == NULL)
                 goto err;
+        wusb_dev->set_gtk_req = req;
 
         req->bRequestType = USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE;
         req->bRequest = USB_REQ_SET_DESCRIPTOR;
@@ -130,9 +133,6 @@ static struct wusb_dev *wusb_dev_alloc(struct wusbhc *wusbhc)
         req->wIndex = 0;
         req->wLength = cpu_to_le16(wusbhc->gtk.descr.bLength);
 
-        wusb_dev->set_gtk_urb = urb;
-        wusb_dev->set_gtk_req = req;
-
         return wusb_dev;
 err:
         wusb_dev_free(wusb_dev);
@@ -438,7 +438,7 @@ static void __wusbhc_keep_alive(struct wusbhc *wusbhc)
         old_keep_alives = ie->hdr.bLength - sizeof(ie->hdr);
         keep_alives = 0;
         for (cnt = 0;
-             keep_alives <= WUIE_ELT_MAX && cnt < wusbhc->ports_max;
+             keep_alives < WUIE_ELT_MAX && cnt < wusbhc->ports_max;
              cnt++) {
                 unsigned tt = msecs_to_jiffies(wusbhc->trust_timeout);
 
@@ -869,7 +869,7 @@ static struct usb_wireless_cap_descriptor wusb_cap_descr_default = {
  * reference that we'll drop.
  *
  * First we need to determine if the device is a WUSB device (else we
- * ignore it). For that we use the speed setting (USB_SPEED_VARIABLE)
+ * ignore it). For that we use the speed setting (USB_SPEED_WIRELESS)
  * [FIXME: maybe we'd need something more definitive]. If so, we track
  * it's usb_busd and from there, the WUSB HC.
  *
diff --git a/drivers/usb/wusbcore/mmc.c b/drivers/usb/wusbcore/mmc.c
index 3b52161e6e9c..0a57ff0a0b0c 100644
--- a/drivers/usb/wusbcore/mmc.c
+++ b/drivers/usb/wusbcore/mmc.c
@@ -37,6 +37,7 @@
  *  - add timers that autoremove intervalled IEs?
  */
 #include <linux/usb/wusb.h>
+#include <linux/slab.h>
 #include "wusbhc.h"
 
 /* Initialize the MMCIEs handling mechanism */
@@ -263,7 +264,7 @@ int wusbhc_chid_set(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
 {
         int result = 0;
 
-        if (memcmp(chid, &wusb_ckhdid_zero, sizeof(chid)) == 0)
+        if (memcmp(chid, &wusb_ckhdid_zero, sizeof(*chid)) == 0)
                 chid = NULL;
 
         mutex_lock(&wusbhc->mutex);
diff --git a/drivers/usb/wusbcore/rh.c b/drivers/usb/wusbcore/rh.c
index 9fe4246cecb9..a68ad7aa0b59 100644
--- a/drivers/usb/wusbcore/rh.c
+++ b/drivers/usb/wusbcore/rh.c
@@ -69,6 +69,7 @@
  *
  * wusbhc_rh_start_port_reset() ??? unimplemented
  */
+#include <linux/slab.h>
 #include "wusbhc.h"
 
 /*
diff --git a/drivers/usb/wusbcore/security.c b/drivers/usb/wusbcore/security.c
index 4516c36436e6..b60799b811c1 100644
--- a/drivers/usb/wusbcore/security.c
+++ b/drivers/usb/wusbcore/security.c
@@ -23,6 +23,7 @@
  * FIXME: docs
  */
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <linux/usb/ch9.h>
 #include <linux/random.h>
 #include "wusbhc.h"
@@ -205,15 +206,15 @@ int wusb_dev_sec_add(struct wusbhc *wusbhc,
         const void *itr, *top;
         char buf[64];
 
-        secd = kmalloc(sizeof(struct usb_security_descriptor), GFP_KERNEL);
+        secd = kmalloc(sizeof(*secd), GFP_KERNEL);
         if (secd == NULL) {
                 result = -ENOMEM;
                 goto out;
         }
 
         result = usb_get_descriptor(usb_dev, USB_DT_SECURITY,
-                                    0, secd, sizeof(struct usb_security_descriptor));
-        if (result < sizeof(secd)) {
+                                    0, secd, sizeof(*secd));
+        if (result < sizeof(*secd)) {
                 dev_err(dev, "Can't read security descriptor or "
                         "not enough data: %d\n", result);
                 goto out;
diff --git a/drivers/usb/wusbcore/wa-hc.c b/drivers/usb/wusbcore/wa-hc.c
index 9d04722415bb..59a748a0e5da 100644
--- a/drivers/usb/wusbcore/wa-hc.c
+++ b/drivers/usb/wusbcore/wa-hc.c
@@ -22,6 +22,7 @@
  *
  * FIXME: docs
  */
+#include <linux/slab.h>
 #include "wusbhc.h"
 #include "wa-hc.h"
 
diff --git a/drivers/usb/wusbcore/wa-nep.c b/drivers/usb/wusbcore/wa-nep.c
index 17d2626038be..f67f7f1e6df9 100644
--- a/drivers/usb/wusbcore/wa-nep.c
+++ b/drivers/usb/wusbcore/wa-nep.c
@@ -51,6 +51,7 @@
  */
 #include <linux/workqueue.h>
 #include <linux/ctype.h>
+#include <linux/slab.h>
 
 #include "wa-hc.h"
 #include "wusbhc.h"
diff --git a/drivers/usb/wusbcore/wa-rpipe.c b/drivers/usb/wusbcore/wa-rpipe.c
index 7369655f69cd..c7b1d8108de9 100644
--- a/drivers/usb/wusbcore/wa-rpipe.c
+++ b/drivers/usb/wusbcore/wa-rpipe.c
@@ -60,6 +60,7 @@
 #include <linux/init.h>
 #include <asm/atomic.h>
 #include <linux/bitmap.h>
+#include <linux/slab.h>
 
 #include "wusbhc.h"
 #include "wa-hc.h"
diff --git a/drivers/usb/wusbcore/wa-xfer.c b/drivers/usb/wusbcore/wa-xfer.c
index 613a5fc490d3..112ef7e26f6b 100644
--- a/drivers/usb/wusbcore/wa-xfer.c
+++ b/drivers/usb/wusbcore/wa-xfer.c
@@ -81,6 +81,7 @@
  */
 #include <linux/init.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <linux/hash.h>
 
 #include "wa-hc.h"
@@ -558,7 +559,7 @@ static void wa_seg_dto_cb(struct urb *urb)
 /*
  * Callback for the segment request
  *
- * If succesful transition state (unless already transitioned or
+ * If successful transition state (unless already transitioned or
  * outbound transfer); otherwise, take a note of the error, mark this
  * segment done and try completion.
  *
@@ -1364,7 +1365,7 @@ segment_aborted:
 /*
  * Callback for the IN data phase
  *
- * If succesful transition state; otherwise, take a note of the
+ * If successful transition state; otherwise, take a note of the
  * error, mark this segment done and try completion.
  *
  * Note we don't access until we are sure that the transfer hasn't
diff --git a/drivers/usb/wusbcore/wusbhc.c b/drivers/usb/wusbcore/wusbhc.c
index ee6256f23636..eab86e4bc770 100644
--- a/drivers/usb/wusbcore/wusbhc.c
+++ b/drivers/usb/wusbcore/wusbhc.c
@@ -147,10 +147,40 @@ static ssize_t wusb_chid_store(struct device *dev,
 }
 static DEVICE_ATTR(wusb_chid, 0644, wusb_chid_show, wusb_chid_store);
 
+
+static ssize_t wusb_phy_rate_show(struct device *dev,
+                                  struct device_attribute *attr,
+                                  char *buf)
+{
+        struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
+
+        return sprintf(buf, "%d\n", wusbhc->phy_rate);
+}
+
+static ssize_t wusb_phy_rate_store(struct device *dev,
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t size)
+{
+        struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
+        uint8_t phy_rate;
+        ssize_t result;
+
+        result = sscanf(buf, "%hhu", &phy_rate);
+        if (result != 1)
+                return -EINVAL;
+        if (phy_rate >= UWB_PHY_RATE_INVALID)
+                return -EINVAL;
+
+        wusbhc->phy_rate = phy_rate;
+        return size;
+}
+static DEVICE_ATTR(wusb_phy_rate, 0644, wusb_phy_rate_show, wusb_phy_rate_store);
+
 /* Group all the WUSBHC attributes */
 static struct attribute *wusbhc_attrs[] = {
                 &dev_attr_wusb_trust_timeout.attr,
                 &dev_attr_wusb_chid.attr,
+                &dev_attr_wusb_phy_rate.attr,
                 NULL,
 };
 
@@ -177,6 +207,8 @@ int wusbhc_create(struct wusbhc *wusbhc)
         int result = 0;
 
         wusbhc->trust_timeout = WUSB_TRUST_TIMEOUT_MS;
+        wusbhc->phy_rate = UWB_PHY_RATE_INVALID - 1;
+
         mutex_init(&wusbhc->mutex);
         result = wusbhc_mmcie_create(wusbhc);
         if (result < 0)
diff --git a/drivers/usb/wusbcore/wusbhc.h b/drivers/usb/wusbcore/wusbhc.h
index 797c2453a35b..759cda55f7c3 100644
--- a/drivers/usb/wusbcore/wusbhc.h
+++ b/drivers/usb/wusbcore/wusbhc.h
@@ -198,7 +198,7 @@ struct wusb_port {
  *                 ports) this HC will take. Read-only.
  *
  * @port           Array of port status for each fake root port. Guaranteed to
- *                 always be the same lenght during device existence
+ *                 always be the same length during device existence
  *                 [this allows for some unlocked but referenced reading].
  *
  * @mmcies_max     Max number of Information Elements this HC can send
@@ -253,6 +253,7 @@ struct wusbhc {
 
         unsigned trust_timeout;                 /* in jiffies */
         struct wusb_ckhdid chid;
+        uint8_t phy_rate;
         struct wuie_host_info *wuie_host_info;
 
         struct mutex mutex;                     /* locks everything else */