30 files changed, 186 insertions, 49 deletions

diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 395a347f2ebb..dac7676ce21b 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -1530,6 +1530,8 @@ static const struct usb_device_id acm_ids[] = {
         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
+        { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
+        { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
 
         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 79a58c3a2e2a..90ae1753dda1 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -339,7 +339,8 @@ static int get_hub_status(struct usb_device *hdev,
 {
         int i, status = -ETIMEDOUT;
 
-        for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
+        for (i = 0; i < USB_STS_RETRIES &&
+                        (status == -ETIMEDOUT || status == -EPIPE); i++) {
                 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
                         USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
                         data, sizeof(*data), USB_STS_TIMEOUT);
@@ -355,7 +356,8 @@ static int get_port_status(struct usb_device *hdev, int port1,
 {
         int i, status = -ETIMEDOUT;
 
-        for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
+        for (i = 0; i < USB_STS_RETRIES &&
+                        (status == -ETIMEDOUT || status == -EPIPE); i++) {
                 status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
                         USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
                         data, sizeof(*data), USB_STS_TIMEOUT);
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 1b125c224dcf..2278dad886e2 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -389,7 +389,6 @@ static int usbfs_rmdir(struct inode *dir, struct dentry *dentry)
         mutex_unlock(&inode->i_mutex);
         if (!error)
                 d_delete(dentry);
-        dput(dentry);
         return error;
 }
 
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index be44545d6809..9468adbe42bb 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -661,13 +661,10 @@ config USB_DUMMY_HCD
 
 endchoice
 
+# Selected by UDC drivers that support high-speed operation.
 config USB_GADGET_DUALSPEED
         bool
         depends on USB_GADGET
-        default n
-        help
-          Means that gadget drivers should include extra descriptors
-          and code to handle dual-speed controllers.
 
 #
 # USB Gadget Drivers
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index 6e42aab75806..95e8138cd48f 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -60,6 +60,7 @@
 #include <linux/device.h>
 #include <linux/io.h>
 #include <linux/irq.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <asm/system.h>
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 41dc093c0a1b..f4690ffcb489 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -38,6 +38,7 @@
 #include <linux/clk.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <mach/hardware.h>
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 61ff927928ab..d3dcabc1a5fc 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -1906,6 +1906,7 @@ static int dummy_hcd_probe(struct platform_device *pdev)
         if (!hcd)
                 return -ENOMEM;
         the_controller = hcd_to_dummy (hcd);
+        hcd->has_tt = 1;
 
         retval = usb_add_hcd(hcd, 0, 0);
         if (retval != 0) {
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index a01383f71f38..a56876aaf76c 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -431,8 +431,10 @@ ep_write (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
 
         /* halt any endpoint by doing a "wrong direction" i/o call */
         if (!usb_endpoint_dir_in(&data->desc)) {
-                if (usb_endpoint_xfer_isoc(&data->desc))
+                if (usb_endpoint_xfer_isoc(&data->desc)) {
+                        mutex_unlock(&data->lock);
                         return -EINVAL;
+                }
                 DBG (data->dev, "%s halt\n", data->name);
                 spin_lock_irq (&data->dev->lock);
                 if (likely (data->ep != NULL))
diff --git a/drivers/usb/gadget/mv_udc_core.c b/drivers/usb/gadget/mv_udc_core.c
index b62b2640deb0..b1a8146b9d50 100644
--- a/drivers/usb/gadget/mv_udc_core.c
+++ b/drivers/usb/gadget/mv_udc_core.c
@@ -2083,7 +2083,7 @@ out:
 }
 
 #ifdef CONFIG_PM
-static int mv_udc_suspend(struct platform_device *_dev, pm_message_t state)
+static int mv_udc_suspend(struct device *_dev)
 {
         struct mv_udc *udc = the_controller;
 
@@ -2092,7 +2092,7 @@ static int mv_udc_suspend(struct platform_device *_dev, pm_message_t state)
         return 0;
 }
 
-static int mv_udc_resume(struct platform_device *_dev)
+static int mv_udc_resume(struct device *_dev)
 {
         struct mv_udc *udc = the_controller;
         int retval;
@@ -2100,7 +2100,7 @@ static int mv_udc_resume(struct platform_device *_dev)
         retval = mv_udc_phy_init(udc->phy_regs);
         if (retval) {
                 dev_err(_dev, "phy initialization error %d\n", retval);
-                goto error;
+                return retval;
         }
         udc_reset(udc);
         ep0_reset(udc);
@@ -2122,7 +2122,7 @@ static struct platform_driver udc_driver = {
                 .owner  = THIS_MODULE,
                 .name   = "pxa-u2o",
 #ifdef CONFIG_PM
-                .pm     = mv_udc_pm_ops,
+                .pm     = &mv_udc_pm_ops,
 #endif
         },
 };
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 24696f7fa6a9..476d88e1ae97 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -63,6 +63,7 @@
 #include <linux/device.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index 365c02fc25fc..774545494cf2 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -2216,7 +2216,6 @@ static int __init pxa25x_udc_probe(struct platform_device *pdev)
                 if (retval != 0) {
                         pr_err("%s: can't get irq %i, err %d\n",
                                 driver_name, LUBBOCK_USB_DISC_IRQ, retval);
-lubbock_fail0:
                         goto err_irq_lub;
                 }
                 retval = request_irq(LUBBOCK_USB_IRQ,
@@ -2226,7 +2225,6 @@ lubbock_fail0:
                 if (retval != 0) {
                         pr_err("%s: can't get irq %i, err %d\n",
                                 driver_name, LUBBOCK_USB_IRQ, retval);
-                        free_irq(LUBBOCK_USB_DISC_IRQ, dev);
                         goto lubbock_fail0;
                 }
         } else
@@ -2236,10 +2234,11 @@ lubbock_fail0:
         return 0;
 
 #ifdef  CONFIG_ARCH_LUBBOCK
+lubbock_fail0:
         free_irq(LUBBOCK_USB_DISC_IRQ, dev);
  err_irq_lub:
-#endif
         free_irq(irq, dev);
+#endif
  err_irq1:
         if (gpio_is_valid(dev->mach->gpio_pullup))
                 gpio_free(dev->mach->gpio_pullup);
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c
index acb9cc418df9..0dfee282878a 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/gadget/s3c-hsotg.c
@@ -2680,9 +2680,9 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
 
         writel(0, hsotg->regs + S3C_DAINTMSK);
 
-        dev_info(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
-                 readl(hsotg->regs + S3C_DIEPCTL0),
-                 readl(hsotg->regs + S3C_DOEPCTL0));
+        dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
+                readl(hsotg->regs + S3C_DIEPCTL0),
+                readl(hsotg->regs + S3C_DOEPCTL0));
 
         /* enable in and out endpoint interrupts */
         s3c_hsotg_en_gsint(hsotg, S3C_GINTSTS_OEPInt | S3C_GINTSTS_IEPInt);
@@ -2701,7 +2701,7 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
         udelay(10);  /* see openiboot */
         __bic32(hsotg->regs + S3C_DCTL, S3C_DCTL_PWROnPrgDone);
 
-        dev_info(hsotg->dev, "DCTL=0x%08x\n", readl(hsotg->regs + S3C_DCTL));
+        dev_dbg(hsotg->dev, "DCTL=0x%08x\n", readl(hsotg->regs + S3C_DCTL));
 
         /* S3C_DxEPCTL_USBActEp says RO in manual, but seems to be set by
            writing to the EPCTL register.. */
@@ -2721,9 +2721,9 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
 
         s3c_hsotg_enqueue_setup(hsotg);
 
-        dev_info(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
-                 readl(hsotg->regs + S3C_DIEPCTL0),
-                 readl(hsotg->regs + S3C_DOEPCTL0));
+        dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
+                readl(hsotg->regs + S3C_DIEPCTL0),
+                readl(hsotg->regs + S3C_DOEPCTL0));
 
         /* clear global NAKs */
         writel(S3C_DCTL_CGOUTNak | S3C_DCTL_CGNPInNAK,
@@ -2921,9 +2921,9 @@ static void s3c_hsotg_init(struct s3c_hsotg *hsotg)
 
         /* setup fifos */
 
-        dev_info(hsotg->dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
-                 readl(hsotg->regs + S3C_GRXFSIZ),
-                 readl(hsotg->regs + S3C_GNPTXFSIZ));
+        dev_dbg(hsotg->dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
+                readl(hsotg->regs + S3C_GRXFSIZ),
+                readl(hsotg->regs + S3C_GNPTXFSIZ));
 
         s3c_hsotg_init_fifo(hsotg);
 
@@ -2945,6 +2945,7 @@ static void s3c_hsotg_init(struct s3c_hsotg *hsotg)
 
 static void s3c_hsotg_dump(struct s3c_hsotg *hsotg)
 {
+#ifdef DEBUG
         struct device *dev = hsotg->dev;
         void __iomem *regs = hsotg->regs;
         u32 val;
@@ -2987,6 +2988,7 @@ static void s3c_hsotg_dump(struct s3c_hsotg *hsotg)
 
         dev_info(dev, "DVBUSDIS=0x%08x, DVBUSPULSE=%08x\n",
                  readl(regs + S3C_DVBUSDIS), readl(regs + S3C_DVBUSPULSE));
+#endif
 }
 
 
diff --git a/drivers/usb/gadget/s3c-hsudc.c b/drivers/usb/gadget/s3c-hsudc.c
index cfe3cf56d6bd..d5e3e1e58626 100644
--- a/drivers/usb/gadget/s3c-hsudc.c
+++ b/drivers/usb/gadget/s3c-hsudc.c
@@ -26,6 +26,7 @@
 #include <linux/clk.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/prefetch.h>
 
 #include <mach/regs-s3c2443-clock.h>
 #include <plat/udc.h>
@@ -1301,7 +1302,8 @@ static int s3c_hsudc_probe(struct platform_device *pdev)
         hsudc->uclk = clk_get(&pdev->dev, "usb-device");
         if (IS_ERR(hsudc->uclk)) {
                 dev_err(dev, "failed to find usb-device clock source\n");
-                return PTR_ERR(hsudc->uclk);
+                ret = PTR_ERR(hsudc->uclk);
+                goto err_clk;
         }
         clk_enable(hsudc->uclk);
 
@@ -1310,7 +1312,8 @@ static int s3c_hsudc_probe(struct platform_device *pdev)
         disable_irq(hsudc->irq);
         local_irq_enable();
         return 0;
-
+err_clk:
+        free_irq(hsudc->irq, hsudc);
 err_irq:
         iounmap(hsudc->regs);
 
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index 6d8b04061d5d..100f2635cf0a 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -36,6 +36,7 @@
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/gpio.h>
+#include <linux/prefetch.h>
 
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index afef7b0a4195..80be5472783a 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -312,8 +312,10 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
                 return PTR_ERR(usb_clk);
 
         hcd = usb_create_hcd (driver, &pdev->dev, "pxa27x");
-        if (!hcd)
-                return -ENOMEM;
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto err0;
+        }
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!r) {
@@ -368,6 +370,7 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
  err1:
         usb_put_hcd(hcd);
+ err0:
         clk_put(usb_clk);
         return retval;
 }
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index 17d3e359ca62..e9b0f043455d 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -438,13 +438,13 @@ char *xhci_get_slot_state(struct xhci_hcd *xhci,
         struct xhci_slot_ctx *slot_ctx = xhci_get_slot_ctx(xhci, ctx);
 
         switch (GET_SLOT_STATE(le32_to_cpu(slot_ctx->dev_state))) {
-        case 0:
+        case SLOT_STATE_ENABLED:
                 return "enabled/disabled";
-        case 1:
+        case SLOT_STATE_DEFAULT:
                 return "default";
-        case 2:
+        case SLOT_STATE_ADDRESSED:
                 return "addressed";
-        case 3:
+        case SLOT_STATE_CONFIGURED:
                 return "configured";
         default:
                 return "reserved";
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 596d8fbb9e18..1370db808fc6 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -985,9 +985,19 @@ static unsigned int xhci_parse_exponent_interval(struct usb_device *udev,
         interval = clamp_val(ep->desc.bInterval, 1, 16) - 1;
         if (interval != ep->desc.bInterval - 1)
                 dev_warn(&udev->dev,
-                         "ep %#x - rounding interval to %d microframes\n",
+                         "ep %#x - rounding interval to %d %sframes\n",
                          ep->desc.bEndpointAddress,
-                         1 << interval);
+                         1 << interval,
+                         udev->speed == USB_SPEED_FULL ? "" : "micro");
+
+        if (udev->speed == USB_SPEED_FULL) {
+                /*
+                 * Full speed isoc endpoints specify interval in frames,
+                 * not microframes. We are using microframes everywhere,
+                 * so adjust accordingly.
+                 */
+                interval += 3;  /* 1 frame = 2^3 uframes */
+        }
 
         return interval;
 }
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index c408e9f6a707..17541d09eabb 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -106,12 +106,22 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
 
         /* Look for vendor-specific quirks */
         if (pdev->vendor == PCI_VENDOR_ID_FRESCO_LOGIC &&
-                        pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK &&
-                        pdev->revision == 0x0) {
+                        pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK) {
+                if (pdev->revision == 0x0) {
                         xhci->quirks |= XHCI_RESET_EP_QUIRK;
                         xhci_dbg(xhci, "QUIRK: Fresco Logic xHC needs configure"
                                         " endpoint cmd after reset endpoint\n");
+                }
+                /* Fresco Logic confirms: all revisions of this chip do not
+                 * support MSI, even though some of them claim to in their PCI
+                 * capabilities.
+                 */
+                xhci->quirks |= XHCI_BROKEN_MSI;
+                xhci_dbg(xhci, "QUIRK: Fresco Logic revision %u "
+                                "has broken MSI implementation\n",
+                                pdev->revision);
         }
+
         if (pdev->vendor == PCI_VENDOR_ID_NEC)
                 xhci->quirks |= XHCI_NEC_HOST;
 
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 4b40e4c95f94..e5530181baa3 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -1778,7 +1778,7 @@ static int skip_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td,
         struct usb_iso_packet_descriptor *frame;
         int idx;
 
-        ep_ring = xhci_dma_to_transfer_ring(ep, event->buffer);
+        ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
         urb_priv = td->urb->hcpriv;
         idx = urb_priv->td_cnt;
         frame = &td->urb->iso_frame_desc[idx];
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 743cf80debb1..d0a65401670b 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -430,12 +430,19 @@ int xhci_run(struct usb_hcd *hcd)
                 free_irq(hcd->irq, hcd);
         hcd->irq = -1;
 
+        /* Some Fresco Logic host controllers advertise MSI, but fail to
+         * generate interrupts.  Don't even try to enable MSI.
+         */
+        if (xhci->quirks & XHCI_BROKEN_MSI)
+                goto legacy_irq;
+
         ret = xhci_setup_msix(xhci);
         if (ret)
                 /* fall back to msi*/
                 ret = xhci_setup_msi(xhci);
 
         if (ret) {
+legacy_irq:
                 /* fall back to legacy interrupt*/
                 ret = request_irq(pdev->irq, &usb_hcd_irq, IRQF_SHARED,
                                         hcd->irq_descr, hcd);
@@ -1848,8 +1855,8 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
 
         /* Free any rings that were dropped, but not changed. */
         for (i = 1; i < 31; ++i) {
-                if ((ctrl_ctx->drop_flags & (1 << (i + 1))) &&
-                                !(ctrl_ctx->add_flags & (1 << (i + 1))))
+                if ((le32_to_cpu(ctrl_ctx->drop_flags) & (1 << (i + 1))) &&
+                    !(le32_to_cpu(ctrl_ctx->add_flags) & (1 << (i + 1))))
                         xhci_free_or_cache_endpoint_ring(xhci, virt_dev, i);
         }
         xhci_zero_in_ctx(xhci, virt_dev);
@@ -2466,6 +2473,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         struct xhci_command *reset_device_cmd;
         int timeleft;
         int last_freed_endpoint;
+        struct xhci_slot_ctx *slot_ctx;
 
         ret = xhci_check_args(hcd, udev, NULL, 0, false, __func__);
         if (ret <= 0)
@@ -2498,6 +2506,12 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
                         return -EINVAL;
         }
 
+        /* If device is not setup, there is no point in resetting it */
+        slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx);
+        if (GET_SLOT_STATE(le32_to_cpu(slot_ctx->dev_state)) ==
+                                                SLOT_STATE_DISABLED)
+                return 0;
+
         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
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index f9098a24d38b..a2cc76741695 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -560,6 +560,11 @@ struct xhci_slot_ctx {
 #define SLOT_STATE      (0x1f << 27)
 #define GET_SLOT_STATE(p)       (((p) & (0x1f << 27)) >> 27)
 
+#define SLOT_STATE_DISABLED     0
+#define SLOT_STATE_ENABLED      SLOT_STATE_DISABLED
+#define SLOT_STATE_DEFAULT      1
+#define SLOT_STATE_ADDRESSED    2
+#define SLOT_STATE_CONFIGURED   3
 
 /**
  * struct xhci_ep_ctx
@@ -1309,6 +1314,7 @@ struct xhci_hcd {
  * commands.
  */
 #define XHCI_EP_LIMIT_QUIRK     (1 << 5)
+#define XHCI_BROKEN_MSI         (1 << 6)
         unsigned int            num_active_eps;
         unsigned int            limit_active_eps;
         /* There are two roothubs to keep track of bus suspend info for */
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index ab8e1001e5e2..c71b0372786e 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -96,6 +96,7 @@
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/kobject.h>
+#include <linux/prefetch.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index 31d28dc78aa3..46e247ad14f3 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -922,5 +922,6 @@ void __devexit usbhs_mod_gadget_remove(struct usbhs_priv *priv)
 {
         struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv);
 
+        kfree(gpriv->uep);
         kfree(gpriv);
 }
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index e8dbde55f6c5..162728977553 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -647,6 +647,7 @@ static struct usb_device_id id_table_combined [] = {
         { 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) },
+        { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_3_PID) },
         { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
         { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
         { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 1d946cd238ba..ab1fcdf3c378 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -351,6 +351,7 @@
  */
 #define FTDI_4N_GALAXY_DE_1_PID 0xF3C0
 #define FTDI_4N_GALAXY_DE_2_PID 0xF3C1
+#define FTDI_4N_GALAXY_DE_3_PID 0xF3C2
 
 /*
  * Linx Technologies product ids
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 318dd00040a3..60b25d8ea0e2 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -311,10 +311,6 @@ static void option_instat_callback(struct urb *urb);
 #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
 
@@ -340,11 +336,12 @@ static void option_instat_callback(struct urb *urb);
 #define TOSHIBA_PRODUCT_G450                    0x0d45
 
 #define ALINK_VENDOR_ID                         0x1e0e
+#define ALINK_PRODUCT_PH300                     0x9100
 #define ALINK_PRODUCT_3GU                       0x9200
 
 /* ALCATEL PRODUCTS */
 #define ALCATEL_VENDOR_ID                       0x1bbb
-#define ALCATEL_PRODUCT_X060S                   0x0000
+#define ALCATEL_PRODUCT_X060S_X200              0x0000
 
 #define PIRELLI_VENDOR_ID                       0x1266
 #define PIRELLI_PRODUCT_C100_1                  0x1002
@@ -379,6 +376,9 @@ static void option_instat_callback(struct urb *urb);
  * It seems to contain a Qualcomm QSC6240/6290 chipset            */
 #define FOUR_G_SYSTEMS_PRODUCT_W14              0x9603
 
+/* Zoom */
+#define ZOOM_PRODUCT_4597                       0x9607
+
 /* Haier products */
 #define HAIER_VENDOR_ID                         0x201e
 #define HAIER_PRODUCT_CE100                     0x2009
@@ -432,6 +432,20 @@ static const struct option_blacklist_info four_g_w14_blacklist = {
         .reason = OPTION_BLACKLIST_SENDSETUP
 };
 
+static const u8 alcatel_x200_no_sendsetup[] = { 0, 1 };
+static const struct option_blacklist_info alcatel_x200_blacklist = {
+        .infolen = ARRAY_SIZE(alcatel_x200_no_sendsetup),
+        .ifaceinfo = alcatel_x200_no_sendsetup,
+        .reason = OPTION_BLACKLIST_SENDSETUP
+};
+
+static const u8 zte_k3765_z_no_sendsetup[] = { 0, 1, 2 };
+static const struct option_blacklist_info zte_k3765_z_blacklist = {
+        .infolen = ARRAY_SIZE(zte_k3765_z_no_sendsetup),
+        .ifaceinfo = zte_k3765_z_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) },
@@ -916,13 +930,13 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0073, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0130, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0141, 0xff, 0xff, 0xff) },
-        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff,
+          0xff, 0xff), .driver_info = (kernel_ulong_t)&zte_k3765_z_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 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 */
@@ -935,13 +949,17 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(TOSHIBA_VENDOR_ID, TOSHIBA_PRODUCT_G450) },
         { USB_DEVICE(TOSHIBA_VENDOR_ID, TOSHIBA_PRODUCT_HSDPA_MINICARD ) }, /* Toshiba 3G HSDPA == Novatel Expedite EU870D MiniCard */
         { USB_DEVICE(ALINK_VENDOR_ID, 0x9000) },
+        { USB_DEVICE(ALINK_VENDOR_ID, ALINK_PRODUCT_PH300) },
         { USB_DEVICE_AND_INTERFACE_INFO(ALINK_VENDOR_ID, ALINK_PRODUCT_3GU, 0xff, 0xff, 0xff) },
-        { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X060S) },
+        { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X060S_X200),
+          .driver_info = (kernel_ulong_t)&alcatel_x200_blacklist
+        },
         { USB_DEVICE(AIRPLUS_VENDOR_ID, AIRPLUS_PRODUCT_MCD650) },
         { USB_DEVICE(TLAYTECH_VENDOR_ID, TLAYTECH_PRODUCT_TEU800) },
         { USB_DEVICE(LONGCHEER_VENDOR_ID, FOUR_G_SYSTEMS_PRODUCT_W14),
           .driver_info = (kernel_ulong_t)&four_g_w14_blacklist
         },
+        { USB_DEVICE(LONGCHEER_VENDOR_ID, ZOOM_PRODUCT_4597) },
         { USB_DEVICE(HAIER_VENDOR_ID, HAIER_PRODUCT_CE100) },
         /* Pirelli  */
         { USB_DEVICE(PIRELLI_VENDOR_ID, PIRELLI_PRODUCT_C100_1)},
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 00418995d8e9..e8ae21b2d387 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -819,6 +819,35 @@ Retry_Sense:
                 }
         }
 
+        /*
+         * Some devices don't work or return incorrect data the first
+         * time they get a READ(10) command, or for the first READ(10)
+         * after a media change.  If the INITIAL_READ10 flag is set,
+         * keep track of whether READ(10) commands succeed.  If the
+         * previous one succeeded and this one failed, set the REDO_READ10
+         * flag to force a retry.
+         */
+        if (unlikely((us->fflags & US_FL_INITIAL_READ10) &&
+                        srb->cmnd[0] == READ_10)) {
+                if (srb->result == SAM_STAT_GOOD) {
+                        set_bit(US_FLIDX_READ10_WORKED, &us->dflags);
+                } else if (test_bit(US_FLIDX_READ10_WORKED, &us->dflags)) {
+                        clear_bit(US_FLIDX_READ10_WORKED, &us->dflags);
+                        set_bit(US_FLIDX_REDO_READ10, &us->dflags);
+                }
+
+                /*
+                 * Next, if the REDO_READ10 flag is set, return a result
+                 * code that will cause the SCSI core to retry the READ(10)
+                 * command immediately.
+                 */
+                if (test_bit(US_FLIDX_REDO_READ10, &us->dflags)) {
+                        clear_bit(US_FLIDX_REDO_READ10, &us->dflags);
+                        srb->result = DID_IMM_RETRY << 16;
+                        srb->sense_buffer[0] = 0;
+                }
+        }
+
         /* Did we transfer less than the minimum amount required? */
         if ((srb->result == SAM_STAT_GOOD || srb->sense_buffer[2] == 0) &&
                         scsi_bufflen(srb) - scsi_get_resid(srb) < srb->underflow)
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index c1602b8c5594..ccff3483eebc 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -1114,6 +1114,16 @@ UNUSUAL_DEV( 0x090c, 0x1132, 0x0000, 0xffff,
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
+/* Reported by Paul Hartman <paul.hartman+linux@gmail.com>
+ * This card reader returns "Illegal Request, Logical Block Address
+ * Out of Range" for the first READ(10) after a new card is inserted.
+ */
+UNUSUAL_DEV(  0x090c, 0x6000, 0x0100, 0x0100,
+                "Feiya",
+                "SD/SDHC Card Reader",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_INITIAL_READ10 ),
+
 /* This Pentax still camera is not conformant
  * to the USB storage specification: -
  * - It does not like the INQUIRY command. So we must handle this command
@@ -1888,6 +1898,15 @@ UNUSUAL_DEV( 0x1908, 0x3335, 0x0200, 0x0200,
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NO_READ_DISC_INFO ),
 
+/* Reported by Sven Geggus <sven-usbst@geggus.net>
+ * This encrypted pen drive returns bogus data for the initial READ(10).
+ */
+UNUSUAL_DEV(  0x1b1c, 0x1ab5, 0x0200, 0x0200,
+                "Corsair",
+                "Padlock v2",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_INITIAL_READ10 ),
+
 /* Patch by Richard Schütz <r.schtz@t-online.de>
  * This external hard drive enclosure uses a JMicron chip which
  * needs the US_FL_IGNORE_RESIDUE flag to work properly. */
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 5ee7ac42e08f..0ca095820f3e 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -440,7 +440,8 @@ static void adjust_quirks(struct us_data *us)
                         US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
                         US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
                         US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT |
-                        US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16);
+                        US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 |
+                        US_FL_INITIAL_READ10);
 
         p = quirks;
         while (*p) {
@@ -490,6 +491,9 @@ static void adjust_quirks(struct us_data *us)
                 case 'm':
                         f |= US_FL_MAX_SECTORS_64;
                         break;
+                case 'n':
+                        f |= US_FL_INITIAL_READ10;
+                        break;
                 case 'o':
                         f |= US_FL_CAPACITY_OK;
                         break;
@@ -953,6 +957,13 @@ int usb_stor_probe2(struct us_data *us)
         if (result)
                 goto BadDevice;
 
+        /*
+         * If the device returns invalid data for the first READ(10)
+         * command, indicate the command should be retried.
+         */
+        if (us->fflags & US_FL_INITIAL_READ10)
+                set_bit(US_FLIDX_REDO_READ10, &us->dflags);
+
         /* Acquire all the other resources and add the host */
         result = usb_stor_acquire_resources(us);
         if (result)
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index 89d3bfff98df..7b0f2113632e 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -73,6 +73,8 @@ struct us_unusual_dev {
 #define US_FLIDX_RESETTING      4       /* device reset in progress */
 #define US_FLIDX_TIMED_OUT      5       /* SCSI midlayer timed out  */
 #define US_FLIDX_DONT_SCAN      6       /* don't scan (disconnect)  */
+#define US_FLIDX_REDO_READ10    7       /* redo READ(10) command    */
+#define US_FLIDX_READ10_WORKED  8       /* previous READ(10) succeeded */
 
 #define USB_STOR_STRING_LEN 32