11 files changed, 91 insertions, 14 deletions

diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 9835e0713943..f5f5601701c9 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -28,6 +28,7 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
+#include <linux/ktime.h>
 #include <linux/list.h>
 #include <linux/interrupt.h>
 #include <linux/usb.h>
@@ -676,6 +677,7 @@ static int ehci_run (struct usb_hcd *hcd)
         ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
         msleep(5);
         up_write(&ehci_cf_port_reset_rwsem);
+        ehci->last_periodic_enable = ktime_get_real();
 
         temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
         ehci_info (ehci,
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 378861b9d79a..ead5f4f2aa5a 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -111,6 +111,10 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
         switch (pdev->vendor) {
         case PCI_VENDOR_ID_INTEL:
                 ehci->need_io_watchdog = 0;
+                if (pdev->device == 0x27cc) {
+                        ehci->broken_periodic = 1;
+                        ehci_info(ehci, "using broken periodic workaround\n");
+                }
                 break;
         case PCI_VENDOR_ID_TDI:
                 if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) {
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 00ad9ce392ed..139a2cc3f641 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -487,8 +487,20 @@ halt:
                          * we must clear the TT buffer (11.17.5).
                          */
                         if (unlikely(last_status != -EINPROGRESS &&
-                                        last_status != -EREMOTEIO))
-                                ehci_clear_tt_buffer(ehci, qh, urb, token);
+                                        last_status != -EREMOTEIO)) {
+                                /* The TT's in some hubs malfunction when they
+                                 * receive this request following a STALL (they
+                                 * stop sending isochronous packets).  Since a
+                                 * STALL can't leave the TT buffer in a busy
+                                 * state (if you believe Figures 11-48 - 11-51
+                                 * in the USB 2.0 spec), we won't clear the TT
+                                 * buffer in this case.  Strictly speaking this
+                                 * is a violation of the spec.
+                                 */
+                                if (last_status != -EPIPE)
+                                        ehci_clear_tt_buffer(ehci, qh, urb,
+                                                        token);
+                        }
                 }
 
                 /* if we're removing something not at the queue head,
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index b25cdea93a1f..a5535b5e3fe2 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -475,6 +475,8 @@ static int enable_periodic (struct ehci_hcd *ehci)
         /* make sure ehci_work scans these */
         ehci->next_uframe = ehci_readl(ehci, &ehci->regs->frame_index)
                 % (ehci->periodic_size << 3);
+        if (unlikely(ehci->broken_periodic))
+                ehci->last_periodic_enable = ktime_get_real();
         return 0;
 }
 
@@ -486,6 +488,16 @@ static int disable_periodic (struct ehci_hcd *ehci)
         if (--ehci->periodic_sched)
                 return 0;
 
+        if (unlikely(ehci->broken_periodic)) {
+                /* delay experimentally determined */
+                ktime_t safe = ktime_add_us(ehci->last_periodic_enable, 1000);
+                ktime_t now = ktime_get_real();
+                s64 delay = ktime_us_delta(safe, now);
+
+                if (unlikely(delay > 0))
+                        udelay(delay);
+        }
+
         /* did setting PSE not take effect yet?
          * takes effect only at frame boundaries...
          */
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 064e76821ff5..2d85e21ff282 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -118,6 +118,7 @@ struct ehci_hcd {			/* one per controller */
         unsigned                stamp;
         unsigned                random_frame;
         unsigned long           next_statechange;
+        ktime_t                 last_periodic_enable;
         u32                     command;
 
         /* SILICON QUIRKS */
@@ -127,6 +128,7 @@ struct ehci_hcd {			/* one per controller */
         unsigned                big_endian_desc:1;
         unsigned                has_amcc_usb23:1;
         unsigned                need_io_watchdog:1;
+        unsigned                broken_periodic:1;
 
         /* required for usb32 quirk */
         #define OHCI_CTRL_HCFS          (3 << 6)
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 78bb7710f36d..24eb74781919 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -87,6 +87,7 @@ static int ohci_restart (struct ohci_hcd *ohci);
 #ifdef CONFIG_PCI
 static void quirk_amd_pll(int state);
 static void amd_iso_dev_put(void);
+static void sb800_prefetch(struct ohci_hcd *ohci, int on);
 #else
 static inline void quirk_amd_pll(int state)
 {
@@ -96,6 +97,10 @@ static inline void amd_iso_dev_put(void)
 {
         return;
 }
+static inline void sb800_prefetch(struct ohci_hcd *ohci, int on)
+{
+        return;
+}
 #endif
 
 
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index d2ba04dd785e..b8a1148f248e 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -177,6 +177,13 @@ static int ohci_quirk_amd700(struct usb_hcd *hcd)
                 return 0;
 
         pci_read_config_byte(amd_smbus_dev, PCI_REVISION_ID, &rev);
+
+        /* SB800 needs pre-fetch fix */
+        if ((rev >= 0x40) && (rev <= 0x4f)) {
+                ohci->flags |= OHCI_QUIRK_AMD_PREFETCH;
+                ohci_dbg(ohci, "enabled AMD prefetch quirk\n");
+        }
+
         if ((rev > 0x3b) || (rev < 0x30)) {
                 pci_dev_put(amd_smbus_dev);
                 amd_smbus_dev = NULL;
@@ -262,6 +269,19 @@ static void amd_iso_dev_put(void)
 
 }
 
+static void sb800_prefetch(struct ohci_hcd *ohci, int on)
+{
+        struct pci_dev *pdev;
+        u16 misc;
+
+        pdev = to_pci_dev(ohci_to_hcd(ohci)->self.controller);
+        pci_read_config_word(pdev, 0x50, &misc);
+        if (on == 0)
+                pci_write_config_word(pdev, 0x50, misc & 0xfcff);
+        else
+                pci_write_config_word(pdev, 0x50, misc | 0x0300);
+}
+
 /* List of quirks for OHCI */
 static const struct pci_device_id ohci_pci_quirks[] = {
         {
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 16fecb8ecc39..35288bcae0db 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -49,9 +49,12 @@ __acquires(ohci->lock)
         switch (usb_pipetype (urb->pipe)) {
         case PIPE_ISOCHRONOUS:
                 ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs--;
-                if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0
-                                && quirk_amdiso(ohci))
-                        quirk_amd_pll(1);
+                if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0) {
+                        if (quirk_amdiso(ohci))
+                                quirk_amd_pll(1);
+                        if (quirk_amdprefetch(ohci))
+                                sb800_prefetch(ohci, 0);
+                }
                 break;
         case PIPE_INTERRUPT:
                 ohci_to_hcd(ohci)->self.bandwidth_int_reqs--;
@@ -680,9 +683,12 @@ static void td_submit_urb (
                                 data + urb->iso_frame_desc [cnt].offset,
                                 urb->iso_frame_desc [cnt].length, urb, cnt);
                 }
-                if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0
-                                && quirk_amdiso(ohci))
-                        quirk_amd_pll(0);
+                if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0) {
+                        if (quirk_amdiso(ohci))
+                                quirk_amd_pll(0);
+                        if (quirk_amdprefetch(ohci))
+                                sb800_prefetch(ohci, 1);
+                }
                 periodic = ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs++ == 0
                         && ohci_to_hcd(ohci)->self.bandwidth_int_reqs == 0;
                 break;
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 222011f6172c..5bf15fed0d9f 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -402,6 +402,7 @@ struct ohci_hcd {
 #define OHCI_QUIRK_FRAME_NO     0x80                    /* no big endian frame_no shift */
 #define OHCI_QUIRK_HUB_POWER    0x100                   /* distrust firmware power/oc setup */
 #define OHCI_QUIRK_AMD_ISO      0x200                   /* ISO transfers*/
+#define OHCI_QUIRK_AMD_PREFETCH 0x400                   /* pre-fetch for ISO transfer */
         // there are also chip quirks/bugs in init logic
 
         struct work_struct      nec_work;       /* Worker for NEC quirk */
@@ -433,6 +434,10 @@ static inline int quirk_amdiso(struct ohci_hcd *ohci)
 {
         return ohci->flags & OHCI_QUIRK_AMD_ISO;
 }
+static inline int quirk_amdprefetch(struct ohci_hcd *ohci)
+{
+        return ohci->flags & OHCI_QUIRK_AMD_PREFETCH;
+}
 #else
 static inline int quirk_nec(struct ohci_hcd *ohci)
 {
@@ -446,6 +451,10 @@ static inline int quirk_amdiso(struct ohci_hcd *ohci)
 {
         return 0;
 }
+static inline int quirk_amdprefetch(struct ohci_hcd *ohci)
+{
+        return 0;
+}
 #endif
 
 /* convert between an hcd pointer and the corresponding ohci_hcd */
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 1db4fea8c170..b8fd270a8b0d 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -802,9 +802,11 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         int i;
 
         /* Free the Event Ring Segment Table and the actual Event Ring */
-        xhci_writel(xhci, 0, &xhci->ir_set->erst_size);
-        xhci_write_64(xhci, 0, &xhci->ir_set->erst_base);
-        xhci_write_64(xhci, 0, &xhci->ir_set->erst_dequeue);
+        if (xhci->ir_set) {
+                xhci_writel(xhci, 0, &xhci->ir_set->erst_size);
+                xhci_write_64(xhci, 0, &xhci->ir_set->erst_base);
+                xhci_write_64(xhci, 0, &xhci->ir_set->erst_dequeue);
+        }
         size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries);
         if (xhci->erst.entries)
                 pci_free_consistent(pdev, size,
@@ -841,9 +843,9 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
                                 xhci->dcbaa, xhci->dcbaa->dma);
         xhci->dcbaa = NULL;
 
+        scratchpad_free(xhci);
         xhci->page_size = 0;
         xhci->page_shift = 0;
-        scratchpad_free(xhci);
 }
 
 int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 173c39c76489..821b7b4709de 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -864,9 +864,11 @@ static struct xhci_segment *trb_in_td(
         cur_seg = start_seg;
 
         do {
+                if (start_dma == 0)
+                        return 0;
                 /* We may get an event for a Link TRB in the middle of a TD */
                 end_seg_dma = xhci_trb_virt_to_dma(cur_seg,
-                                &start_seg->trbs[TRBS_PER_SEGMENT - 1]);
+                                &cur_seg->trbs[TRBS_PER_SEGMENT - 1]);
                 /* If the end TRB isn't in this segment, this is set to 0 */
                 end_trb_dma = xhci_trb_virt_to_dma(cur_seg, end_trb);
 
@@ -893,8 +895,9 @@ static struct xhci_segment *trb_in_td(
                 }
                 cur_seg = cur_seg->next;
                 start_dma = xhci_trb_virt_to_dma(cur_seg, &cur_seg->trbs[0]);
-        } while (1);
+        } while (cur_seg != start_seg);
 
+        return 0;
 }
 
 /*