Merge branch 'master' into next

49 files changed, 344 insertions, 163 deletions

diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index ea071a5b6eee..44447f54942f 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -2301,7 +2301,7 @@ out:
         return ret;
 }
 
-static DEVICE_ATTR(stat_status, S_IWUGO | S_IRUGO, read_status, reboot);
+static DEVICE_ATTR(stat_status, S_IWUSR | S_IRUGO, read_status, reboot);
 
 static ssize_t read_human_status(struct device *dev,
                         struct device_attribute *attr, char *buf)
@@ -2364,8 +2364,7 @@ out:
         return ret;
 }
 
-static DEVICE_ATTR(stat_human_status, S_IWUGO | S_IRUGO,
-                                read_human_status, NULL);
+static DEVICE_ATTR(stat_human_status, S_IRUGO, read_human_status, NULL);
 
 static ssize_t read_delin(struct device *dev, struct device_attribute *attr,
                 char *buf)
@@ -2397,7 +2396,7 @@ out:
         return ret;
 }
 
-static DEVICE_ATTR(stat_delin, S_IWUGO | S_IRUGO, read_delin, NULL);
+static DEVICE_ATTR(stat_delin, S_IRUGO, read_delin, NULL);
 
 #define UEA_ATTR(name, reset)                                   \
                                                                 \
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index ddb4dc980923..a3d2e2399655 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -54,7 +54,6 @@
 #include <linux/gfp.h>
 #include <linux/poll.h>
 #include <linux/usb.h>
-#include <linux/smp_lock.h>
 #include <linux/usbdevice_fs.h>
 #include <linux/usb/hcd.h>
 #include <linux/mutex.h>
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index f1aaff6202a5..a7131ad630f9 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -37,7 +37,6 @@
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/signal.h>
 #include <linux/poll.h>
 #include <linux/module.h>
@@ -965,10 +964,11 @@ static int proc_getdriver(struct dev_state *ps, void __user *arg)
 
 static int proc_connectinfo(struct dev_state *ps, void __user *arg)
 {
-        struct usbdevfs_connectinfo ci;
+        struct usbdevfs_connectinfo ci = {
+                .devnum = ps->dev->devnum,
+                .slow = ps->dev->speed == USB_SPEED_LOW
+        };
 
-        ci.devnum = ps->dev->devnum;
-        ci.slow = ps->dev->speed == USB_SPEED_LOW;
         if (copy_to_user(arg, &ci, sizeof(ci)))
                 return -EFAULT;
         return 0;
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index 9fe34fb78ef1..cf6a5423de09 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -19,7 +19,6 @@
 #include <linux/errno.h>
 #include <linux/rwsem.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/usb.h>
 
 #include "usb.h"
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 9819a4cc3b26..b690aa35df9a 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -39,7 +39,6 @@
 #include <linux/parser.h>
 #include <linux/notifier.h>
 #include <linux/seq_file.h>
-#include <linux/smp_lock.h>
 #include <linux/usb/hcd.h>
 #include <asm/byteorder.h>
 #include "usb.h"
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index b739ca814651..607d0db4a988 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -158,7 +158,7 @@ config USB_GADGET_FSL_USB2
         boolean "Freescale Highspeed USB DR Peripheral Controller"
         depends on FSL_SOC || ARCH_MXC
         select USB_GADGET_DUALSPEED
-        select USB_FSL_MPH_DR_OF
+        select USB_FSL_MPH_DR_OF if OF
         help
            Some of Freescale PowerPC processors have a High Speed
            Dual-Role(DR) USB controller, which supports device mode.
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index b5e20e873cba..717ff653fa23 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -2017,7 +2017,7 @@ static int __init usba_udc_probe(struct platform_device *pdev)
                         }
                 } else {
                         /* gpio_request fail so use -EINVAL for gpio_is_valid */
-                        ubc->vbus_pin = -EINVAL;
+                        udc->vbus_pin = -EINVAL;
                 }
         }
 
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index 4a830df4fc31..484c5ba5450e 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -30,7 +30,6 @@
 #include <linux/blkdev.h>
 #include <linux/pagemap.h>
 #include <asm/unaligned.h>
-#include <linux/smp_lock.h>
 
 #include <linux/usb/composite.h>
 #include <linux/usb/functionfs.h>
diff --git a/drivers/usb/gadget/f_hid.c b/drivers/usb/gadget/f_hid.c
index 4f891eddd060..598e7e2ab80c 100644
--- a/drivers/usb/gadget/f_hid.c
+++ b/drivers/usb/gadget/f_hid.c
@@ -25,7 +25,6 @@
 #include <linux/cdev.h>
 #include <linux/mutex.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 #include <linux/uaccess.h>
 #include <linux/wait.h>
 #include <linux/usb/g_hid.h>
diff --git a/drivers/usb/gadget/goku_udc.h b/drivers/usb/gadget/goku_udc.h
index 566cb2319056..e7e0c69d3b1f 100644
--- a/drivers/usb/gadget/goku_udc.h
+++ b/drivers/usb/gadget/goku_udc.h
@@ -251,7 +251,8 @@ struct goku_udc {
                                         got_region:1,
                                         req_config:1,
                                         configured:1,
-                                        enabled:1;
+                                        enabled:1,
+                                        registered:1;
 
         /* pci state used to access those endpoints */
         struct pci_dev                  *pdev;
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
index 01e5354a4c20..40f7716b31fc 100644
--- a/drivers/usb/gadget/u_serial.c
+++ b/drivers/usb/gadget/u_serial.c
@@ -105,11 +105,15 @@ struct gs_port {
         wait_queue_head_t       close_wait;     /* wait for last close */
 
         struct list_head        read_pool;
+        int read_started;
+        int read_allocated;
         struct list_head        read_queue;
         unsigned                n_read;
         struct tasklet_struct   push;
 
         struct list_head        write_pool;
+        int write_started;
+        int write_allocated;
         struct gs_buf           port_write_buf;
         wait_queue_head_t       drain_wait;     /* wait while writes drain */
 
@@ -363,6 +367,9 @@ __acquires(&port->port_lock)
                 struct usb_request      *req;
                 int                     len;
 
+                if (port->write_started >= QUEUE_SIZE)
+                        break;
+
                 req = list_entry(pool->next, struct usb_request, list);
                 len = gs_send_packet(port, req->buf, in->maxpacket);
                 if (len == 0) {
@@ -397,6 +404,8 @@ __acquires(&port->port_lock)
                         break;
                 }
 
+                port->write_started++;
+
                 /* abort immediately after disconnect */
                 if (!port->port_usb)
                         break;
@@ -418,7 +427,6 @@ __acquires(&port->port_lock)
 {
         struct list_head        *pool = &port->read_pool;
         struct usb_ep           *out = port->port_usb->out;
-        unsigned                started = 0;
 
         while (!list_empty(pool)) {
                 struct usb_request      *req;
@@ -430,6 +438,9 @@ __acquires(&port->port_lock)
                 if (!tty)
                         break;
 
+                if (port->read_started >= QUEUE_SIZE)
+                        break;
+
                 req = list_entry(pool->next, struct usb_request, list);
                 list_del(&req->list);
                 req->length = out->maxpacket;
@@ -447,13 +458,13 @@ __acquires(&port->port_lock)
                         list_add(&req->list, pool);
                         break;
                 }
-                started++;
+                port->read_started++;
 
                 /* abort immediately after disconnect */
                 if (!port->port_usb)
                         break;
         }
-        return started;
+        return port->read_started;
 }
 
 /*
@@ -535,6 +546,7 @@ static void gs_rx_push(unsigned long _port)
                 }
 recycle:
                 list_move(&req->list, &port->read_pool);
+                port->read_started--;
         }
 
         /* Push from tty to ldisc; without low_latency set this is handled by
@@ -587,6 +599,7 @@ static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
 
         spin_lock(&port->port_lock);
         list_add(&req->list, &port->write_pool);
+        port->write_started--;
 
         switch (req->status) {
         default:
@@ -608,7 +621,8 @@ static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
         spin_unlock(&port->port_lock);
 }
 
-static void gs_free_requests(struct usb_ep *ep, struct list_head *head)
+static void gs_free_requests(struct usb_ep *ep, struct list_head *head,
+                                                         int *allocated)
 {
         struct usb_request      *req;
 
@@ -616,25 +630,31 @@ static void gs_free_requests(struct usb_ep *ep, struct list_head *head)
                 req = list_entry(head->next, struct usb_request, list);
                 list_del(&req->list);
                 gs_free_req(ep, req);
+                if (allocated)
+                        (*allocated)--;
         }
 }
 
 static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
-                void (*fn)(struct usb_ep *, struct usb_request *))
+                void (*fn)(struct usb_ep *, struct usb_request *),
+                int *allocated)
 {
         int                     i;
         struct usb_request      *req;
+        int n = allocated ? QUEUE_SIZE - *allocated : QUEUE_SIZE;
 
         /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't
          * do quite that many this time, don't fail ... we just won't
          * be as speedy as we might otherwise be.
          */
-        for (i = 0; i < QUEUE_SIZE; i++) {
+        for (i = 0; i < n; i++) {
                 req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
                 if (!req)
                         return list_empty(head) ? -ENOMEM : 0;
                 req->complete = fn;
                 list_add_tail(&req->list, head);
+                if (allocated)
+                        (*allocated)++;
         }
         return 0;
 }
@@ -661,14 +681,15 @@ static int gs_start_io(struct gs_port *port)
          * configurations may use different endpoints with a given port;
          * and high speed vs full speed changes packet sizes too.
          */
-        status = gs_alloc_requests(ep, head, gs_read_complete);
+        status = gs_alloc_requests(ep, head, gs_read_complete,
+                &port->read_allocated);
         if (status)
                 return status;
 
         status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
-                        gs_write_complete);
+                        gs_write_complete, &port->write_allocated);
         if (status) {
-                gs_free_requests(ep, head);
+                gs_free_requests(ep, head, &port->read_allocated);
                 return status;
         }
 
@@ -680,8 +701,9 @@ static int gs_start_io(struct gs_port *port)
         if (started) {
                 tty_wakeup(port->port_tty);
         } else {
-                gs_free_requests(ep, head);
-                gs_free_requests(port->port_usb->in, &port->write_pool);
+                gs_free_requests(ep, head, &port->read_allocated);
+                gs_free_requests(port->port_usb->in, &port->write_pool,
+                        &port->write_allocated);
                 status = -EIO;
         }
 
@@ -1315,8 +1337,12 @@ void gserial_disconnect(struct gserial *gser)
         spin_lock_irqsave(&port->port_lock, flags);
         if (port->open_count == 0 && !port->openclose)
                 gs_buf_free(&port->port_write_buf);
-        gs_free_requests(gser->out, &port->read_pool);
-        gs_free_requests(gser->out, &port->read_queue);
-        gs_free_requests(gser->in, &port->write_pool);
+        gs_free_requests(gser->out, &port->read_pool, NULL);
+        gs_free_requests(gser->out, &port->read_queue, NULL);
+        gs_free_requests(gser->in, &port->write_pool, NULL);
+
+        port->read_allocated = port->read_started =
+                port->write_allocated = port->write_started = 0;
+
         spin_unlock_irqrestore(&port->port_lock, flags);
 }
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 2391c396ca32..6f4f8e6a40c7 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -122,7 +122,7 @@ config USB_EHCI_FSL
         bool "Support for Freescale on-chip EHCI USB controller"
         depends on USB_EHCI_HCD && FSL_SOC
         select USB_EHCI_ROOT_HUB_TT
-        select USB_FSL_MPH_DR_OF
+        select USB_FSL_MPH_DR_OF if OF
         ---help---
           Variation of ARC USB block used in some Freescale chips.
 
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 86afdc73322f..6e2599661b5b 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -1067,7 +1067,7 @@ static inline void create_debug_files (struct ehci_hcd *ehci)
                                                     &debug_registers_fops))
                 goto file_error;
 
-        if (!debugfs_create_file("lpm", S_IRUGO|S_IWUGO, ehci->debug_dir, bus,
+        if (!debugfs_create_file("lpm", S_IRUGO|S_IWUSR, ehci->debug_dir, bus,
                                                     &debug_lpm_fops))
                 goto file_error;
 
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 502a7e6fef42..e9062806d4a2 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -1063,10 +1063,11 @@ rescan:
                                 tmp && tmp != qh;
                                 tmp = tmp->qh_next.qh)
                         continue;
-                /* periodic qh self-unlinks on empty */
-                if (!tmp)
-                        goto nogood;
-                unlink_async (ehci, qh);
+                /* periodic qh self-unlinks on empty, and a COMPLETING qh
+                 * may already be unlinked.
+                 */
+                if (tmp)
+                        unlink_async(ehci, qh);
                 /* FALL THROUGH */
         case QH_STATE_UNLINK:           /* wait for hw to finish? */
         case QH_STATE_UNLINK_WAIT:
@@ -1083,7 +1084,6 @@ idle_timeout:
                 }
                 /* else FALL THROUGH */
         default:
-nogood:
                 /* caller was supposed to have unlinked any requests;
                  * that's not our job.  just leak this memory.
                  */
diff --git a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c
index d36e4e75e08d..12f70c302b0b 100644
--- a/drivers/usb/host/ehci-mem.c
+++ b/drivers/usb/host/ehci-mem.c
@@ -141,6 +141,10 @@ static void ehci_mem_cleanup (struct ehci_hcd *ehci)
                 qh_put (ehci->async);
         ehci->async = NULL;
 
+        if (ehci->dummy)
+                qh_put(ehci->dummy);
+        ehci->dummy = NULL;
+
         /* DMA consistent memory and pools */
         if (ehci->qtd_pool)
                 dma_pool_destroy (ehci->qtd_pool);
@@ -227,8 +231,26 @@ static int ehci_mem_init (struct ehci_hcd *ehci, gfp_t flags)
         if (ehci->periodic == NULL) {
                 goto fail;
         }
-        for (i = 0; i < ehci->periodic_size; i++)
-                ehci->periodic [i] = EHCI_LIST_END(ehci);
+
+        if (ehci->use_dummy_qh) {
+                struct ehci_qh_hw       *hw;
+                ehci->dummy = ehci_qh_alloc(ehci, flags);
+                if (!ehci->dummy)
+                        goto fail;
+
+                hw = ehci->dummy->hw;
+                hw->hw_next = EHCI_LIST_END(ehci);
+                hw->hw_qtd_next = EHCI_LIST_END(ehci);
+                hw->hw_alt_next = EHCI_LIST_END(ehci);
+                hw->hw_token &= ~QTD_STS_ACTIVE;
+                ehci->dummy->hw = hw;
+
+                for (i = 0; i < ehci->periodic_size; i++)
+                        ehci->periodic[i] = ehci->dummy->qh_dma;
+        } else {
+                for (i = 0; i < ehci->periodic_size; i++)
+                        ehci->periodic[i] = EHCI_LIST_END(ehci);
+        }
 
         /* software shadow of hardware table */
         ehci->pshadow = kcalloc(ehci->periodic_size, sizeof(void *), flags);
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index ac9c4d7c44af..bce85055019a 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -36,6 +36,8 @@ struct ehci_mxc_priv {
 static int ehci_mxc_setup(struct usb_hcd *hcd)
 {
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct device *dev = hcd->self.controller;
+        struct mxc_usbh_platform_data *pdata = dev_get_platdata(dev);
         int retval;
 
         /* EHCI registers start at offset 0x100 */
@@ -63,6 +65,12 @@ static int ehci_mxc_setup(struct usb_hcd *hcd)
 
         ehci_reset(ehci);
 
+        /* set up the PORTSCx register */
+        ehci_writel(ehci, pdata->portsc, &ehci->regs->port_status[0]);
+
+        /* is this really needed? */
+        msleep(10);
+
         ehci_port_power(ehci, 0);
         return 0;
 }
@@ -114,7 +122,7 @@ 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;
+        int irq, ret;
         struct ehci_mxc_priv *priv;
         struct device *dev = &pdev->dev;
 
@@ -188,10 +196,6 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
                 clk_enable(priv->ahbclk);
         }
 
-        /* set up the PORTSCx register */
-        ehci_writel(ehci, pdata->portsc, &ehci->regs->port_status[0]);
-        mdelay(10);
-
         /* setup specific usb hw */
         ret = mxc_initialize_usb_hw(pdev->id, pdata->flags);
         if (ret < 0)
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index a1e8d273103f..01bb72b71832 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -103,6 +103,19 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
         if (retval)
                 return retval;
 
+        if ((pdev->vendor == PCI_VENDOR_ID_AMD && pdev->device == 0x7808) ||
+            (pdev->vendor == PCI_VENDOR_ID_ATI && pdev->device == 0x4396)) {
+                /* EHCI controller on AMD SB700/SB800/Hudson-2/3 platforms may
+                 * read/write memory space which does not belong to it when
+                 * there is NULL pointer with T-bit set to 1 in the frame list
+                 * table. To avoid the issue, the frame list link pointer
+                 * should always contain a valid pointer to a inactive qh.
+                 */
+                ehci->use_dummy_qh = 1;
+                ehci_info(ehci, "applying AMD SB700/SB800/Hudson-2/3 EHCI "
+                                "dummy qh workaround\n");
+        }
+
         /* data structure init */
         retval = ehci_init(hcd);
         if (retval)
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index a92526d6e5ae..d9f78eb26572 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -98,7 +98,14 @@ static void periodic_unlink (struct ehci_hcd *ehci, unsigned frame, void *ptr)
          */
         *prev_p = *periodic_next_shadow(ehci, &here,
                         Q_NEXT_TYPE(ehci, *hw_p));
-        *hw_p = *shadow_next_periodic(ehci, &here, Q_NEXT_TYPE(ehci, *hw_p));
+
+        if (!ehci->use_dummy_qh ||
+            *shadow_next_periodic(ehci, &here, Q_NEXT_TYPE(ehci, *hw_p))
+                        != EHCI_LIST_END(ehci))
+                *hw_p = *shadow_next_periodic(ehci, &here,
+                                Q_NEXT_TYPE(ehci, *hw_p));
+        else
+                *hw_p = ehci->dummy->qh_dma;
 }
 
 /* how many of the uframe's 125 usecs are allocated? */
@@ -2335,7 +2342,11 @@ restart:
                                  * pointer for much longer, if at all.
                                  */
                                 *q_p = q.itd->itd_next;
-                                *hw_p = q.itd->hw_next;
+                                if (!ehci->use_dummy_qh ||
+                                    q.itd->hw_next != EHCI_LIST_END(ehci))
+                                        *hw_p = q.itd->hw_next;
+                                else
+                                        *hw_p = ehci->dummy->qh_dma;
                                 type = Q_NEXT_TYPE(ehci, q.itd->hw_next);
                                 wmb();
                                 modified = itd_complete (ehci, q.itd);
@@ -2368,7 +2379,11 @@ restart:
                                  * URB completion.
                                  */
                                 *q_p = q.sitd->sitd_next;
-                                *hw_p = q.sitd->hw_next;
+                                if (!ehci->use_dummy_qh ||
+                                    q.sitd->hw_next != EHCI_LIST_END(ehci))
+                                        *hw_p = q.sitd->hw_next;
+                                else
+                                        *hw_p = ehci->dummy->qh_dma;
                                 type = Q_NEXT_TYPE(ehci, q.sitd->hw_next);
                                 wmb();
                                 modified = sitd_complete (ehci, q.sitd);
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index bde823f704e9..ba8eab366b82 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -73,6 +73,7 @@ struct ehci_hcd {			/* one per controller */
 
         /* async schedule support */
         struct ehci_qh          *async;
+        struct ehci_qh          *dummy;         /* For AMD quirk use */
         struct ehci_qh          *reclaim;
         unsigned                scanning : 1;
 
@@ -131,6 +132,7 @@ struct ehci_hcd {			/* one per controller */
         unsigned                need_io_watchdog:1;
         unsigned                broken_periodic:1;
         unsigned                fs_i_thresh:1;  /* Intel iso scheduling */
+        unsigned                use_dummy_qh:1; /* AMD Frame List table quirk*/
 
         /* required for usb32 quirk */
         #define OHCI_CTRL_HCFS          (3 << 6)
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index 8196fa11fec4..43a39eb56cc6 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -70,7 +70,6 @@
 #include <linux/ioport.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/list.h>
@@ -2684,7 +2683,7 @@ static int __devexit isp1362_remove(struct platform_device *pdev)
         return 0;
 }
 
-static int __init isp1362_probe(struct platform_device *pdev)
+static int __devinit isp1362_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd;
         struct isp1362_hcd *isp1362_hcd;
diff --git a/drivers/usb/host/ohci-jz4740.c b/drivers/usb/host/ohci-jz4740.c
index 10e1872f3ab9..931d588c3fb5 100644
--- a/drivers/usb/host/ohci-jz4740.c
+++ b/drivers/usb/host/ohci-jz4740.c
@@ -273,4 +273,4 @@ static struct platform_driver ohci_hcd_jz4740_driver = {
         },
 };
 
-MODULE_ALIAS("platfrom:jz4740-ohci");
+MODULE_ALIAS("platform:jz4740-ohci");
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index 6e7fb5f38db6..ee60cd3ea642 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -12,7 +12,6 @@
 #include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/debugfs.h>
-#include <linux/smp_lock.h>
 #include <asm/io.h>
 
 #include "uhci-hcd.h"
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 202770676da3..d178761c3981 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1045,7 +1045,7 @@ static inline u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
         if (udev->speed == USB_SPEED_SUPER)
                 return ep->ss_ep_comp.wBytesPerInterval;
 
-        max_packet = ep->desc.wMaxPacketSize & 0x3ff;
+        max_packet = GET_MAX_PACKET(ep->desc.wMaxPacketSize);
         max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11;
         /* A 0 in max burst means 1 transfer per ESIT */
         return max_packet * (max_burst + 1);
@@ -1135,7 +1135,7 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
                 /* Fall through */
         case USB_SPEED_FULL:
         case USB_SPEED_LOW:
-                max_packet = ep->desc.wMaxPacketSize & 0x3ff;
+                max_packet = GET_MAX_PACKET(ep->desc.wMaxPacketSize);
                 ep_ctx->ep_info2 |= MAX_PACKET(max_packet);
                 break;
         default:
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 9f3115e729b1..df558f6f84e3 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -2104,7 +2104,6 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd)
 
         if (!(status & STS_EINT)) {
                 spin_unlock(&xhci->lock);
-                xhci_warn(xhci, "Spurious interrupt.\n");
                 return IRQ_NONE;
         }
         xhci_dbg(xhci, "op reg status = %08x\n", status);
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 5d7d4e951ea4..06fca0835b52 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -577,6 +577,65 @@ static void xhci_restore_registers(struct xhci_hcd *xhci)
         xhci_write_64(xhci, xhci->s3.erst_base, &xhci->ir_set->erst_base);
 }
 
+static void xhci_set_cmd_ring_deq(struct xhci_hcd *xhci)
+{
+        u64     val_64;
+
+        /* step 2: initialize command ring buffer */
+        val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
+        val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) |
+                (xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
+                                      xhci->cmd_ring->dequeue) &
+                 (u64) ~CMD_RING_RSVD_BITS) |
+                xhci->cmd_ring->cycle_state;
+        xhci_dbg(xhci, "// Setting command ring address to 0x%llx\n",
+                        (long unsigned long) val_64);
+        xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring);
+}
+
+/*
+ * The whole command ring must be cleared to zero when we suspend the host.
+ *
+ * The host doesn't save the command ring pointer in the suspend well, so we
+ * need to re-program it on resume.  Unfortunately, the pointer must be 64-byte
+ * aligned, because of the reserved bits in the command ring dequeue pointer
+ * register.  Therefore, we can't just set the dequeue pointer back in the
+ * middle of the ring (TRBs are 16-byte aligned).
+ */
+static void xhci_clear_command_ring(struct xhci_hcd *xhci)
+{
+        struct xhci_ring *ring;
+        struct xhci_segment *seg;
+
+        ring = xhci->cmd_ring;
+        seg = ring->deq_seg;
+        do {
+                memset(seg->trbs, 0, SEGMENT_SIZE);
+                seg = seg->next;
+        } while (seg != ring->deq_seg);
+
+        /* Reset the software enqueue and dequeue pointers */
+        ring->deq_seg = ring->first_seg;
+        ring->dequeue = ring->first_seg->trbs;
+        ring->enq_seg = ring->deq_seg;
+        ring->enqueue = ring->dequeue;
+
+        /*
+         * Ring is now zeroed, so the HW should look for change of ownership
+         * when the cycle bit is set to 1.
+         */
+        ring->cycle_state = 1;
+
+        /*
+         * Reset the hardware dequeue pointer.
+         * Yes, this will need to be re-written after resume, but we're paranoid
+         * and want to make sure the hardware doesn't access bogus memory
+         * because, say, the BIOS or an SMI started the host without changing
+         * the command ring pointers.
+         */
+        xhci_set_cmd_ring_deq(xhci);
+}
+
 /*
  * Stop HC (not bus-specific)
  *
@@ -604,6 +663,7 @@ int xhci_suspend(struct xhci_hcd *xhci)
                 spin_unlock_irq(&xhci->lock);
                 return -ETIMEDOUT;
         }
+        xhci_clear_command_ring(xhci);
 
         /* step 3: save registers */
         xhci_save_registers(xhci);
@@ -635,7 +695,6 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
         u32                     command, temp = 0;
         struct usb_hcd          *hcd = xhci_to_hcd(xhci);
         struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
-        u64     val_64;
         int     old_state, retval;
 
         old_state = hcd->state;
@@ -648,15 +707,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                 /* step 1: restore register */
                 xhci_restore_registers(xhci);
                 /* step 2: initialize command ring buffer */
-                val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
-                val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) |
-                         (xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
-                                               xhci->cmd_ring->dequeue) &
-                         (u64) ~CMD_RING_RSVD_BITS) |
-                         xhci->cmd_ring->cycle_state;
-                xhci_dbg(xhci, "// Setting command ring address to 0x%llx\n",
-                                (long unsigned long) val_64);
-                xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring);
+                xhci_set_cmd_ring_deq(xhci);
                 /* step 3: restore state and start state*/
                 /* step 3: set CRS flag */
                 command = xhci_readl(xhci, &xhci->op_regs->command);
@@ -714,6 +765,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                 return retval;
         }
 
+        spin_unlock_irq(&xhci->lock);
         /* Re-setup MSI-X */
         if (hcd->irq)
                 free_irq(hcd->irq, hcd);
@@ -736,6 +788,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                 hcd->irq = pdev->irq;
         }
 
+        spin_lock_irq(&xhci->lock);
         /* step 4: set Run/Stop bit */
         command = xhci_readl(xhci, &xhci->op_regs->command);
         command |= CMD_RUN;
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 93d3bf4d213c..85e65647d445 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -621,6 +621,11 @@ struct xhci_ep_ctx {
 #define MAX_PACKET_MASK         (0xffff << 16)
 #define MAX_PACKET_DECODED(p)   (((p) >> 16) & 0xffff)
 
+/* Get max packet size from ep desc. Bit 10..0 specify the max packet size.
+ * USB2.0 spec 9.6.6.
+ */
+#define GET_MAX_PACKET(p)       ((p) & 0x7ff)
+
 /* tx_info bitmasks */
 #define AVG_TRB_LENGTH_FOR_EP(p)        ((p) & 0xffff)
 #define MAX_ESIT_PAYLOAD_FOR_EP(p)      (((p) & 0xffff) << 16)
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 5a47805d9580..c90c89dc0003 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -364,7 +364,7 @@ static int mts_scsi_host_reset(struct scsi_cmnd *srb)
 }
 
 static int
-mts_scsi_queuecommand(struct scsi_cmnd *srb, mts_scsi_cmnd_callback callback);
+mts_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *srb);
 
 static void mts_transfer_cleanup( struct urb *transfer );
 static void mts_do_sg(struct urb * transfer);
@@ -573,7 +573,7 @@ mts_build_transfer_context(struct scsi_cmnd *srb, struct mts_desc* desc)
 
 
 static int
-mts_scsi_queuecommand(struct scsi_cmnd *srb, mts_scsi_cmnd_callback callback)
+mts_scsi_queuecommand_lck(struct scsi_cmnd *srb, mts_scsi_cmnd_callback callback)
 {
         struct mts_desc* desc = (struct mts_desc*)(srb->device->host->hostdata[0]);
         int err = 0;
@@ -626,6 +626,8 @@ out:
         return err;
 }
 
+static DEF_SCSI_QCMD(mts_scsi_queuecommand)
+
 static struct scsi_host_template mts_scsi_host_template = {
         .module                 = THIS_MODULE,
         .name                   = "microtekX6",
diff --git a/drivers/usb/misc/cypress_cy7c63.c b/drivers/usb/misc/cypress_cy7c63.c
index 2f43c57743c9..9251773ecef4 100644
--- a/drivers/usb/misc/cypress_cy7c63.c
+++ b/drivers/usb/misc/cypress_cy7c63.c
@@ -196,11 +196,9 @@ static ssize_t get_port1_handler(struct device *dev,
         return read_port(dev, attr, buf, 1, CYPRESS_READ_PORT_ID1);
 }
 
-static DEVICE_ATTR(port0, S_IWUGO | S_IRUGO,
-                   get_port0_handler, set_port0_handler);
+static DEVICE_ATTR(port0, S_IRUGO | S_IWUSR, get_port0_handler, set_port0_handler);
 
-static DEVICE_ATTR(port1, S_IWUGO | S_IRUGO,
-                   get_port1_handler, set_port1_handler);
+static DEVICE_ATTR(port1, S_IRUGO | S_IWUSR, get_port1_handler, set_port1_handler);
 
 
 static int cypress_probe(struct usb_interface *interface,
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index 375664198776..c9078e4e1f4d 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -553,6 +553,7 @@ static long iowarrior_ioctl(struct file *file, unsigned int cmd,
                         /* needed for power consumption */
                         struct usb_config_descriptor *cfg_descriptor = &dev->udev->actconfig->desc;
 
+                        memset(&info, 0, sizeof(info));
                         /* directly from the descriptor */
                         info.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
                         info.product = dev->product_id;
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index 70d00e99a4b4..dd573abd2d1e 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -3008,6 +3008,7 @@ sisusb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 #else
                         x.sisusb_conactive  = 0;
 #endif
+                        memset(x.sisusb_reserved, 0, sizeof(x.sisusb_reserved));
 
                         if (copy_to_user((void __user *)arg, &x, sizeof(x)))
                                 retval = -EFAULT;
diff --git a/drivers/usb/misc/trancevibrator.c b/drivers/usb/misc/trancevibrator.c
index d77aba46ae85..f63776a48e2a 100644
--- a/drivers/usb/misc/trancevibrator.c
+++ b/drivers/usb/misc/trancevibrator.c
@@ -86,7 +86,7 @@ static ssize_t set_speed(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-static DEVICE_ATTR(speed, S_IWUGO | S_IRUGO, show_speed, set_speed);
+static DEVICE_ATTR(speed, S_IRUGO | S_IWUSR, show_speed, set_speed);
 
 static int tv_probe(struct usb_interface *interface,
                     const struct usb_device_id *id)
diff --git a/drivers/usb/misc/usbled.c b/drivers/usb/misc/usbled.c
index 63da2c3c838f..c96f51de1696 100644
--- a/drivers/usb/misc/usbled.c
+++ b/drivers/usb/misc/usbled.c
@@ -94,7 +94,7 @@ static ssize_t set_##value(struct device *dev, struct device_attribute *attr, co
         change_color(led);                                              \
         return count;                                                   \
 }                                                                       \
-static DEVICE_ATTR(value, S_IWUGO | S_IRUGO, show_##value, set_##value);
+static DEVICE_ATTR(value, S_IRUGO | S_IWUSR, show_##value, set_##value);
 show_set(blue);
 show_set(red);
 show_set(green);
diff --git a/drivers/usb/misc/usbsevseg.c b/drivers/usb/misc/usbsevseg.c
index de8ef945b536..417b8f207e8b 100644
--- a/drivers/usb/misc/usbsevseg.c
+++ b/drivers/usb/misc/usbsevseg.c
@@ -192,7 +192,7 @@ static ssize_t set_attr_##name(struct device *dev, 		\
                                                                 \
         return count;                                           \
 }                                                               \
-static DEVICE_ATTR(name, S_IWUGO | S_IRUGO, show_attr_##name, set_attr_##name);
+static DEVICE_ATTR(name, S_IRUGO | S_IWUSR, show_attr_##name, set_attr_##name);
 
 static ssize_t show_attr_text(struct device *dev,
         struct device_attribute *attr, char *buf)
@@ -223,7 +223,7 @@ static ssize_t set_attr_text(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(text, S_IWUGO | S_IRUGO, show_attr_text, set_attr_text);
+static DEVICE_ATTR(text, S_IRUGO | S_IWUSR, show_attr_text, set_attr_text);
 
 static ssize_t show_attr_decimals(struct device *dev,
         struct device_attribute *attr, char *buf)
@@ -272,8 +272,7 @@ static ssize_t set_attr_decimals(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(decimals, S_IWUGO | S_IRUGO,
-        show_attr_decimals, set_attr_decimals);
+static DEVICE_ATTR(decimals, S_IRUGO | S_IWUSR, show_attr_decimals, set_attr_decimals);
 
 static ssize_t show_attr_textmode(struct device *dev,
         struct device_attribute *attr, char *buf)
@@ -319,8 +318,7 @@ static ssize_t set_attr_textmode(struct device *dev,
         return -EINVAL;
 }
 
-static DEVICE_ATTR(textmode, S_IWUGO | S_IRUGO,
-        show_attr_textmode, set_attr_textmode);
+static DEVICE_ATTR(textmode, S_IRUGO | S_IWUSR, show_attr_textmode, set_attr_textmode);
 
 
 MYDEV_ATTR_SIMPLE_UNSIGNED(powered, update_display_powered);
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index 44cb37b5a4dc..c436e1e2c3b6 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -15,7 +15,6 @@
 #include <linux/poll.h>
 #include <linux/compat.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
 
diff --git a/drivers/usb/mon/mon_stat.c b/drivers/usb/mon/mon_stat.c
index 8ec94f15a738..e5ce42bd316e 100644
--- a/drivers/usb/mon/mon_stat.c
+++ b/drivers/usb/mon/mon_stat.c
@@ -11,7 +11,6 @@
 #include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 
 #include "usb_mon.h"
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index 611a9d274363..fcb5206a65bd 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -171,8 +171,9 @@ static irqreturn_t blackfin_interrupt(int irq, void *__hci)
         }
 
         /* Start sampling ID pin, when plug is removed from MUSB */
-        if (is_otg_enabled(musb) && (musb->xceiv->state == OTG_STATE_B_IDLE
-                || musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
+        if ((is_otg_enabled(musb) && (musb->xceiv->state == OTG_STATE_B_IDLE
+                || musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) ||
+                (musb->int_usb & MUSB_INTR_DISCONNECT && is_host_active(musb))) {
                 mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
                 musb->a_wait_bcon = TIMER_DELAY;
         }
@@ -323,30 +324,8 @@ int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
         return -EIO;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static void musb_platform_reg_init(struct musb *musb)
 {
-
-        /*
-         * Rev 1.0 BF549 EZ-KITs require PE7 to be high for both DEVICE
-         * and OTG HOST modes, while rev 1.1 and greater require PE7 to
-         * be low for DEVICE mode and high for HOST mode. We set it high
-         * here because we are in host mode
-         */
-
-        if (gpio_request(musb->config->gpio_vrsel, "USB_VRSEL")) {
-                printk(KERN_ERR "Failed ro request USB_VRSEL GPIO_%d \n",
-                        musb->config->gpio_vrsel);
-                return -ENODEV;
-        }
-        gpio_direction_output(musb->config->gpio_vrsel, 0);
-
-        usb_nop_xceiv_register();
-        musb->xceiv = otg_get_transceiver();
-        if (!musb->xceiv) {
-                gpio_free(musb->config->gpio_vrsel);
-                return -ENODEV;
-        }
-
         if (ANOMALY_05000346) {
                 bfin_write_USB_APHY_CALIB(ANOMALY_05000346_value);
                 SSYNC();
@@ -358,7 +337,8 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
         }
 
         /* Configure PLL oscillator register */
-        bfin_write_USB_PLLOSC_CTRL(0x30a8);
+        bfin_write_USB_PLLOSC_CTRL(0x3080 |
+                        ((480/musb->config->clkin) << 1));
         SSYNC();
 
         bfin_write_USB_SRP_CLKDIV((get_sclk()/1000) / 32 - 1);
@@ -380,6 +360,33 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                                 EP2_RX_ENA | EP3_RX_ENA | EP4_RX_ENA |
                                 EP5_RX_ENA | EP6_RX_ENA | EP7_RX_ENA);
         SSYNC();
+}
+
+int __init musb_platform_init(struct musb *musb, void *board_data)
+{
+
+        /*
+         * Rev 1.0 BF549 EZ-KITs require PE7 to be high for both DEVICE
+         * and OTG HOST modes, while rev 1.1 and greater require PE7 to
+         * be low for DEVICE mode and high for HOST mode. We set it high
+         * here because we are in host mode
+         */
+
+        if (gpio_request(musb->config->gpio_vrsel, "USB_VRSEL")) {
+                printk(KERN_ERR "Failed ro request USB_VRSEL GPIO_%d\n",
+                        musb->config->gpio_vrsel);
+                return -ENODEV;
+        }
+        gpio_direction_output(musb->config->gpio_vrsel, 0);
+
+        usb_nop_xceiv_register();
+        musb->xceiv = otg_get_transceiver();
+        if (!musb->xceiv) {
+                gpio_free(musb->config->gpio_vrsel);
+                return -ENODEV;
+        }
+
+        musb_platform_reg_init(musb);
 
         if (is_host_enabled(musb)) {
                 musb->board_set_vbus = bfin_set_vbus;
@@ -394,6 +401,27 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
         return 0;
 }
 
+#ifdef CONFIG_PM
+void musb_platform_save_context(struct musb *musb,
+                        struct musb_context_registers *musb_context)
+{
+        if (is_host_active(musb))
+                /*
+                 * During hibernate gpio_vrsel will change from high to low
+                 * low which will generate wakeup event resume the system
+                 * immediately.  Set it to 0 before hibernate to avoid this
+                 * wakeup event.
+                 */
+                gpio_set_value(musb->config->gpio_vrsel, 0);
+}
+
+void musb_platform_restore_context(struct musb *musb,
+                        struct musb_context_registers *musb_context)
+{
+        musb_platform_reg_init(musb);
+}
+#endif
+
 int musb_platform_exit(struct musb *musb)
 {
         gpio_free(musb->config->gpio_vrsel);
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index c9f9024c5515..e6669fc3b804 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -552,7 +552,8 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
         if (int_usb & MUSB_INTR_SESSREQ) {
                 void __iomem *mbase = musb->mregs;
 
-                if (devctl & MUSB_DEVCTL_BDEVICE) {
+                if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS
+                                && (devctl & MUSB_DEVCTL_BDEVICE)) {
                         DBG(3, "SessReq while on B state\n");
                         return IRQ_HANDLED;
                 }
@@ -1052,6 +1053,11 @@ static void musb_shutdown(struct platform_device *pdev)
                 clk_put(musb->clock);
         spin_unlock_irqrestore(&musb->lock, flags);
 
+        if (!is_otg_enabled(musb) && is_host_enabled(musb))
+                usb_remove_hcd(musb_to_hcd(musb));
+        musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
+        musb_platform_exit(musb);
+
         /* FIXME power down */
 }
 
@@ -2244,13 +2250,6 @@ static int __exit musb_remove(struct platform_device *pdev)
          */
         musb_exit_debugfs(musb);
         musb_shutdown(pdev);
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-        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);
@@ -2411,9 +2410,6 @@ static int musb_suspend(struct device *dev)
         unsigned long   flags;
         struct musb     *musb = dev_to_musb(&pdev->dev);
 
-        if (!musb->clock)
-                return 0;
-
         spin_lock_irqsave(&musb->lock, flags);
 
         if (is_peripheral_active(musb)) {
@@ -2428,10 +2424,12 @@ static int musb_suspend(struct device *dev)
 
         musb_save_context(musb);
 
-        if (musb->set_clock)
-                musb->set_clock(musb->clock, 0);
-        else
-                clk_disable(musb->clock);
+        if (musb->clock) {
+                if (musb->set_clock)
+                        musb->set_clock(musb->clock, 0);
+                else
+                        clk_disable(musb->clock);
+        }
         spin_unlock_irqrestore(&musb->lock, flags);
         return 0;
 }
@@ -2441,13 +2439,12 @@ static int musb_resume_noirq(struct device *dev)
         struct platform_device *pdev = to_platform_device(dev);
         struct musb     *musb = dev_to_musb(&pdev->dev);
 
-        if (!musb->clock)
-                return 0;
-
-        if (musb->set_clock)
-                musb->set_clock(musb->clock, 1);
-        else
-                clk_enable(musb->clock);
+        if (musb->clock) {
+                if (musb->set_clock)
+                        musb->set_clock(musb->clock, 1);
+                else
+                        clk_enable(musb->clock);
+        }
 
         musb_restore_context(musb);
 
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 69797e5b46a7..febaabcc2b35 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -487,7 +487,7 @@ struct musb_context_registers {
 };
 
 #if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) || \
-    defined(CONFIG_ARCH_OMAP4)
+    defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_BLACKFIN)
 extern void musb_platform_save_context(struct musb *musb,
                 struct musb_context_registers *musb_context);
 extern void musb_platform_restore_context(struct musb *musb,
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 5d815049cbaa..36cfd060dbe5 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -644,10 +644,8 @@ static void rxstate(struct musb *musb, struct musb_request *req)
          */
 
                                 csr |= MUSB_RXCSR_DMAENAB;
-                                if (!musb_ep->hb_mult &&
-                                        musb_ep->hw_ep->rx_double_buffered)
-                                        csr |= MUSB_RXCSR_AUTOCLEAR;
 #ifdef USE_MODE1
+                                csr |= MUSB_RXCSR_AUTOCLEAR;
                                 /* csr |= MUSB_RXCSR_DMAMODE; */
 
                                 /* this special sequence (enabling and then
@@ -656,6 +654,10 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                  */
                                 musb_writew(epio, MUSB_RXCSR,
                                         csr | MUSB_RXCSR_DMAMODE);
+#else
+                                if (!musb_ep->hb_mult &&
+                                        musb_ep->hw_ep->rx_double_buffered)
+                                        csr |= MUSB_RXCSR_AUTOCLEAR;
 #endif
                                 musb_writew(epio, MUSB_RXCSR, csr);
 
@@ -807,7 +809,7 @@ void musb_g_rx(struct musb *musb, u8 epnum)
 
 #if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_TUSB_OMAP_DMA)
                 /* Autoclear doesn't clear RxPktRdy for short packets */
-                if ((dma->desired_mode == 0)
+                if ((dma->desired_mode == 0 && !hw_ep->rx_double_buffered)
                                 || (dma->actual_len
                                         & (musb_ep->packet_sz - 1))) {
                         /* ack the read! */
@@ -818,8 +820,16 @@ void musb_g_rx(struct musb *musb, u8 epnum)
                 /* incomplete, and not short? wait for next IN packet */
                 if ((request->actual < request->length)
                                 && (musb_ep->dma->actual_len
-                                        == musb_ep->packet_sz))
+                                        == musb_ep->packet_sz)) {
+                        /* In double buffer case, continue to unload fifo if
+                         * there is Rx packet in FIFO.
+                         **/
+                        csr = musb_readw(epio, MUSB_RXCSR);
+                        if ((csr & MUSB_RXCSR_RXPKTRDY) &&
+                                hw_ep->rx_double_buffered)
+                                goto exit;
                         return;
+                }
 #endif
                 musb_g_giveback(musb_ep, request, 0);
 
@@ -827,7 +837,7 @@ void musb_g_rx(struct musb *musb, u8 epnum)
                 if (!request)
                         return;
         }
-
+exit:
         /* Analyze request */
         rxstate(musb, to_musb_request(request));
 }
@@ -916,13 +926,9 @@ static int musb_gadget_enable(struct usb_ep *ep,
                  * likewise high bandwidth periodic tx
                  */
                 /* 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.
+                 * to disable double buffering mode.
                  */
-                if (musb->hwvers < MUSB_HWVERS_2000)
-                        musb_writew(regs, MUSB_TXMAXP, hw_ep->max_packet_sz_tx);
-                else
-                        musb_writew(regs, MUSB_TXMAXP, musb_ep->packet_sz | (musb_ep->hb_mult << 11));
+                musb_writew(regs, MUSB_TXMAXP, musb_ep->packet_sz | (musb_ep->hb_mult << 11));
 
                 csr = MUSB_TXCSR_MODE | MUSB_TXCSR_CLRDATATOG;
                 if (musb_readw(regs, MUSB_TXCSR)
@@ -958,10 +964,7 @@ static int musb_gadget_enable(struct usb_ep *ep,
                 /* 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, musb_ep->packet_sz | (musb_ep->hb_mult << 11));
+                musb_writew(regs, MUSB_RXMAXP, musb_ep->packet_sz | (musb_ep->hb_mult << 11));
 
                 /* force shared fifo to OUT-only mode */
                 if (hw_ep->is_shared_fifo) {
@@ -1166,8 +1169,6 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
                                                 : DMA_FROM_DEVICE);
                         request->mapped = 0;
                 }
-        } else if (!req->buf) {
-                return -ENODATA;
         } else
                 request->mapped = 0;
 
@@ -1695,8 +1696,10 @@ int __init musb_gadget_setup(struct musb *musb)
         musb_platform_try_idle(musb, 0);
 
         status = device_register(&musb->g.dev);
-        if (status != 0)
+        if (status != 0) {
+                put_device(&musb->g.dev);
                 the_gadget = NULL;
+        }
         return status;
 }
 
diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index 244267527a60..5a727c5b8676 100644
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -633,8 +633,9 @@ static inline u8  musb_read_txhubaddr(void __iomem *mbase, u8 epnum)
         return 0;
 }
 
-static inline void  musb_read_txhubport(void __iomem *mbase, u8 epnum)
+static inline u8 musb_read_txhubport(void __iomem *mbase, u8 epnum)
 {
+        return 0;
 }
 
 #endif /* CONFIG_BLACKFIN */
diff --git a/drivers/usb/musb/musbhsdma.c b/drivers/usb/musb/musbhsdma.c
index 6f771af5cbdb..563114d613d6 100644
--- a/drivers/usb/musb/musbhsdma.c
+++ b/drivers/usb/musb/musbhsdma.c
@@ -158,6 +158,8 @@ static int dma_channel_program(struct dma_channel *channel,
                                 dma_addr_t dma_addr, u32 len)
 {
         struct musb_dma_channel *musb_channel = channel->private_data;
+        struct musb_dma_controller *controller = musb_channel->controller;
+        struct musb *musb = controller->private_data;
 
         DBG(2, "ep%d-%s pkt_sz %d, dma_addr 0x%x length %d, mode %d\n",
                 musb_channel->epnum,
@@ -167,6 +169,18 @@ static int dma_channel_program(struct dma_channel *channel,
         BUG_ON(channel->status == MUSB_DMA_STATUS_UNKNOWN ||
                 channel->status == MUSB_DMA_STATUS_BUSY);
 
+        /*
+         * The DMA engine in RTL1.8 and above cannot handle
+         * DMA addresses that are not aligned to a 4 byte boundary.
+         * It ends up masking the last two bits of the address
+         * programmed in DMA_ADDR.
+         *
+         * Fail such DMA transfers, so that the backup PIO mode
+         * can carry out the transfer
+         */
+        if ((musb->hwvers >= MUSB_HWVERS_1800) && (dma_addr % 4))
+                return false;
+
         channel->actual_len = 0;
         musb_channel->start_addr = dma_addr;
         musb_channel->len = len;
diff --git a/drivers/usb/otg/langwell_otg.c b/drivers/usb/otg/langwell_otg.c
index bdc3ea66be69..9fea48264fa2 100644
--- a/drivers/usb/otg/langwell_otg.c
+++ b/drivers/usb/otg/langwell_otg.c
@@ -1896,7 +1896,7 @@ set_a_bus_req(struct device *dev, struct device_attribute *attr,
         }
         return count;
 }
-static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUGO, get_a_bus_req, set_a_bus_req);
+static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUSR, get_a_bus_req, set_a_bus_req);
 
 static ssize_t
 get_a_bus_drop(struct device *dev, struct device_attribute *attr, char *buf)
@@ -1942,8 +1942,7 @@ set_a_bus_drop(struct device *dev, struct device_attribute *attr,
         }
         return count;
 }
-static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUGO,
-        get_a_bus_drop, set_a_bus_drop);
+static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUSR, get_a_bus_drop, set_a_bus_drop);
 
 static ssize_t
 get_b_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
@@ -1988,7 +1987,7 @@ set_b_bus_req(struct device *dev, struct device_attribute *attr,
         }
         return count;
 }
-static DEVICE_ATTR(b_bus_req, S_IRUGO | S_IWUGO, get_b_bus_req, set_b_bus_req);
+static DEVICE_ATTR(b_bus_req, S_IRUGO | S_IWUSR, get_b_bus_req, set_b_bus_req);
 
 static ssize_t
 set_a_clr_err(struct device *dev, struct device_attribute *attr,
@@ -2012,7 +2011,7 @@ set_a_clr_err(struct device *dev, struct device_attribute *attr,
         }
         return count;
 }
-static DEVICE_ATTR(a_clr_err, S_IWUGO, NULL, set_a_clr_err);
+static DEVICE_ATTR(a_clr_err, S_IWUSR, NULL, set_a_clr_err);
 
 static struct attribute *inputs_attrs[] = {
         &dev_attr_a_bus_req.attr,
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 89a9a5847803..76f8b3556672 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -794,6 +794,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LOGBOOKML_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LS_LOGBOOK_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_HS_LOGBOOK_PID) },
+        { USB_DEVICE(QIHARDWARE_VID, MILKYMISTONE_JTAGSERIAL_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 7dfe02f1fb6a..263f62551197 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -1100,3 +1100,10 @@
 #define FTDI_SCIENCESCOPE_LOGBOOKML_PID         0xFF18
 #define FTDI_SCIENCESCOPE_LS_LOGBOOK_PID        0xFF1C
 #define FTDI_SCIENCESCOPE_HS_LOGBOOK_PID        0xFF1D
+
+/*
+ * Milkymist One JTAG/Serial
+ */
+#define QIHARDWARE_VID                  0x20B7
+#define MILKYMISTONE_JTAGSERIAL_PID     0x0713
+
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 2297fb1bcf65..ef2977d3a613 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -518,7 +518,7 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4505, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3765, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_ETS1220, 0xff, 0xff, 0xff) },
-        { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E14AC) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E14AC, 0xff, 0xff, 0xff) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V740) },
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index e64da74bdcc5..861223f2af6e 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -21,7 +21,6 @@
 #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>
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index a688b1e686ea..689ee1fb702a 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -285,7 +285,7 @@ static int slave_configure(struct scsi_device *sdev)
 
 /* queue a command */
 /* This is always called with scsi_lock(host) held */
-static int queuecommand(struct scsi_cmnd *srb,
+static int queuecommand_lck(struct scsi_cmnd *srb,
                         void (*done)(struct scsi_cmnd *))
 {
         struct us_data *us = host_to_us(srb->device->host);
@@ -315,6 +315,8 @@ static int queuecommand(struct scsi_cmnd *srb,
         return 0;
 }
 
+static DEF_SCSI_QCMD(queuecommand)
+
 /***********************************************************************
  * Error handling functions
  ***********************************************************************/
diff --git a/drivers/usb/storage/sierra_ms.c b/drivers/usb/storage/sierra_ms.c
index 57fc2f532cab..ceba512f84d0 100644
--- a/drivers/usb/storage/sierra_ms.c
+++ b/drivers/usb/storage/sierra_ms.c
@@ -121,7 +121,7 @@ static ssize_t show_truinst(struct device *dev, struct device_attribute *attr,
         }
         return result;
 }
-static DEVICE_ATTR(truinst, S_IWUGO | S_IRUGO, show_truinst, NULL);
+static DEVICE_ATTR(truinst, S_IRUGO, show_truinst, NULL);
 
 int sierra_ms_init(struct us_data *us)
 {
diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
index 2054b1e25a65..339fac3949df 100644
--- a/drivers/usb/storage/uas.c
+++ b/drivers/usb/storage/uas.c
@@ -331,10 +331,7 @@ static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
 
         iu->iu_id = IU_ID_COMMAND;
         iu->tag = cpu_to_be16(stream_id);
-        if (sdev->ordered_tags && (cmnd->request->cmd_flags & REQ_HARDBARRIER))
-                iu->prio_attr = UAS_ORDERED_TAG;
-        else
-                iu->prio_attr = UAS_SIMPLE_TAG;
+        iu->prio_attr = UAS_SIMPLE_TAG;
         iu->len = len;
         int_to_scsilun(sdev->lun, &iu->lun);
         memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
@@ -433,7 +430,7 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
         return 0;
 }
 
-static int uas_queuecommand(struct scsi_cmnd *cmnd,
+static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
                                         void (*done)(struct scsi_cmnd *))
 {
         struct scsi_device *sdev = cmnd->device;
@@ -491,6 +488,8 @@ static int uas_queuecommand(struct scsi_cmnd *cmnd,
         return 0;
 }
 
+static DEF_SCSI_QCMD(uas_queuecommand)
+
 static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
 {
         struct scsi_device *sdev = cmnd->device;