12 files changed, 90 insertions, 49 deletions

diff --git a/drivers/usb/host/ehci-exynos.c b/drivers/usb/host/ehci-exynos.c
index d1d8c47777c5..7f425acd9be5 100644
--- a/drivers/usb/host/ehci-exynos.c
+++ b/drivers/usb/host/ehci-exynos.c
@@ -212,6 +212,8 @@ static int exynos_ehci_suspend(struct device *dev)
         int rc;
 
         rc = ehci_suspend(hcd, do_wakeup);
+        if (rc)
+                return rc;
 
         if (exynos_ehci->otg)
                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 6f2c8d3899d2..cf2734b532a7 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -248,7 +248,8 @@ static int ehci_fsl_setup_phy(struct usb_hcd *hcd,
                 break;
         }
 
-        if (pdata->have_sysif_regs && pdata->controller_ver &&
+        if (pdata->have_sysif_regs &&
+            pdata->controller_ver > FSL_USB_VER_1_6 &&
             (phy_mode == FSL_USB2_PHY_ULPI)) {
                 /* check PHY_CLK_VALID to get phy clk valid */
                 if (!(spin_event_timeout(in_be32(non_ehci + FSL_SOC_USB_CTRL) &
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index b3a0e11073aa..c7dd93aad20c 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -303,6 +303,8 @@ static int ehci_platform_suspend(struct device *dev)
         int ret;
 
         ret = ehci_suspend(hcd, do_wakeup);
+        if (ret)
+                return ret;
 
         if (pdata->power_suspend)
                 pdata->power_suspend(pdev);
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 27ac6ad53c3d..7ef00ecb0da1 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -509,8 +509,31 @@ static struct platform_driver tegra_ehci_driver = {
         }
 };
 
+static int tegra_ehci_reset(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+        int txfifothresh;
+
+        retval = ehci_setup(hcd);
+        if (retval)
+                return retval;
+
+        /*
+         * We should really pull this value out of tegra_ehci_soc_config, but
+         * to avoid needing access to it, make use of the fact that Tegra20 is
+         * the only one so far that needs a value of 10, and Tegra20 is the
+         * only one which doesn't set has_hostpc.
+         */
+        txfifothresh = ehci->has_hostpc ? 0x10 : 10;
+        ehci_writel(ehci, txfifothresh << 16, &ehci->regs->txfill_tuning);
+
+        return 0;
+}
+
 static const struct ehci_driver_overrides tegra_overrides __initconst = {
         .extra_priv_size        = sizeof(struct tegra_ehci_hcd),
+        .reset                  = tegra_ehci_reset,
 };
 
 static int __init ehci_tegra_init(void)
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index c81c8721cc5a..cd871b895013 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -90,6 +90,24 @@ __acquires(ohci->lock)
         dl_done_list (ohci);
         finish_unlinks (ohci, ohci_frame_no(ohci));
 
+        /*
+         * Some controllers don't handle "global" suspend properly if
+         * there are unsuspended ports.  For these controllers, put all
+         * the enabled ports into suspend before suspending the root hub.
+         */
+        if (ohci->flags & OHCI_QUIRK_GLOBAL_SUSPEND) {
+                __hc32 __iomem  *portstat = ohci->regs->roothub.portstatus;
+                int             i;
+                unsigned        temp;
+
+                for (i = 0; i < ohci->num_ports; (++i, ++portstat)) {
+                        temp = ohci_readl(ohci, portstat);
+                        if ((temp & (RH_PS_PES | RH_PS_PSS)) ==
+                                        RH_PS_PES)
+                                ohci_writel(ohci, RH_PS_PSS, portstat);
+                }
+        }
+
         /* maybe resume can wake root hub */
         if (ohci_to_hcd(ohci)->self.root_hub->do_remote_wakeup || autostop) {
                 ohci->hc_control |= OHCI_CTRL_RWE;
diff --git a/drivers/usb/host/ohci-jz4740.c b/drivers/usb/host/ohci-jz4740.c
index af8dc1b92d75..c2c221a332eb 100644
--- a/drivers/usb/host/ohci-jz4740.c
+++ b/drivers/usb/host/ohci-jz4740.c
@@ -82,14 +82,14 @@ static int ohci_jz4740_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
         u16 wIndex, char *buf, u16 wLength)
 {
         struct jz4740_ohci_hcd *jz4740_ohci = hcd_to_jz4740_hcd(hcd);
-        int ret;
+        int ret = 0;
 
         switch (typeReq) {
-        case SetHubFeature:
+        case SetPortFeature:
                 if (wValue == USB_PORT_FEAT_POWER)
                         ret = ohci_jz4740_set_vbus_power(jz4740_ohci, true);
                 break;
-        case ClearHubFeature:
+        case ClearPortFeature:
                 if (wValue == USB_PORT_FEAT_POWER)
                         ret = ohci_jz4740_set_vbus_power(jz4740_ohci, false);
                 break;
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index 90879e9ccbec..bb1509675727 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -160,6 +160,7 @@ static int ohci_quirk_amd700(struct usb_hcd *hcd)
                 ohci_dbg(ohci, "enabled AMD prefetch quirk\n");
         }
 
+        ohci->flags |= OHCI_QUIRK_GLOBAL_SUSPEND;
         return 0;
 }
 
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 9250cada13f0..4550ce05af7f 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -405,6 +405,8 @@ struct ohci_hcd {
 #define OHCI_QUIRK_HUB_POWER    0x100                   /* distrust firmware power/oc setup */
 #define OHCI_QUIRK_AMD_PLL      0x200                   /* AMD PLL quirk*/
 #define OHCI_QUIRK_AMD_PREFETCH 0x400                   /* pre-fetch for ISO transfer */
+#define OHCI_QUIRK_GLOBAL_SUSPEND       0x800           /* must suspend ports */
+
         // there are also chip quirks/bugs in init logic
 
         struct work_struct      nec_work;       /* Worker for NEC quirk */
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 47390e369cd4..35d447780707 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -134,6 +134,8 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                  */
                 if (pdev->subsystem_vendor == PCI_VENDOR_ID_HP)
                         xhci->quirks |= XHCI_SPURIOUS_WAKEUP;
+
+                xhci->quirks |= XHCI_SPURIOUS_REBOOT;
         }
         if (pdev->vendor == PCI_VENDOR_ID_ETRON &&
                         pdev->device == PCI_DEVICE_ID_ASROCK_P67) {
@@ -143,9 +145,7 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                 xhci->quirks |= XHCI_TRUST_TX_LENGTH;
         }
         if (pdev->vendor == PCI_VENDOR_ID_RENESAS &&
-                        pdev->device == 0x0015 &&
-                        pdev->subsystem_vendor == PCI_VENDOR_ID_SAMSUNG &&
-                        pdev->subsystem_device == 0xc0cd)
+                        pdev->device == 0x0015)
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
         if (pdev->vendor == PCI_VENDOR_ID_VIA)
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 5f926bea5ab1..7a0e3c720c00 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -550,6 +550,7 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
         struct xhci_ring *ep_ring;
         struct xhci_generic_trb *trb;
         dma_addr_t addr;
+        u64 hw_dequeue;
 
         ep_ring = xhci_triad_to_transfer_ring(xhci, slot_id,
                         ep_index, stream_id);
@@ -559,16 +560,6 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                                 stream_id);
                 return;
         }
-        state->new_cycle_state = 0;
-        xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
-                        "Finding segment containing stopped TRB.");
-        state->new_deq_seg = find_trb_seg(cur_td->start_seg,
-                        dev->eps[ep_index].stopped_trb,
-                        &state->new_cycle_state);
-        if (!state->new_deq_seg) {
-                WARN_ON(1);
-                return;
-        }
 
         /* Dig out the cycle state saved by the xHC during the stop ep cmd */
         xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
@@ -577,46 +568,57 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
         if (ep->ep_state & EP_HAS_STREAMS) {
                 struct xhci_stream_ctx *ctx =
                         &ep->stream_info->stream_ctx_array[stream_id];
-                state->new_cycle_state = 0x1 & le64_to_cpu(ctx->stream_ring);
+                hw_dequeue = le64_to_cpu(ctx->stream_ring);
         } else {
                 struct xhci_ep_ctx *ep_ctx
                         = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
-                state->new_cycle_state = 0x1 & le64_to_cpu(ep_ctx->deq);
+                hw_dequeue = le64_to_cpu(ep_ctx->deq);
         }
 
+        /* Find virtual address and segment of hardware dequeue pointer */
+        state->new_deq_seg = ep_ring->deq_seg;
+        state->new_deq_ptr = ep_ring->dequeue;
+        while (xhci_trb_virt_to_dma(state->new_deq_seg, state->new_deq_ptr)
+                        != (dma_addr_t)(hw_dequeue & ~0xf)) {
+                next_trb(xhci, ep_ring, &state->new_deq_seg,
+                                        &state->new_deq_ptr);
+                if (state->new_deq_ptr == ep_ring->dequeue) {
+                        WARN_ON(1);
+                        return;
+                }
+        }
+        /*
+         * Find cycle state for last_trb, starting at old cycle state of
+         * hw_dequeue. If there is only one segment ring, find_trb_seg() will
+         * return immediately and cannot toggle the cycle state if this search
+         * wraps around, so add one more toggle manually in that case.
+         */
+        state->new_cycle_state = hw_dequeue & 0x1;
+        if (ep_ring->first_seg == ep_ring->first_seg->next &&
+                        cur_td->last_trb < state->new_deq_ptr)
+                state->new_cycle_state ^= 0x1;
+
         state->new_deq_ptr = cur_td->last_trb;
         xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
                         "Finding segment containing last TRB in TD.");
         state->new_deq_seg = find_trb_seg(state->new_deq_seg,
-                        state->new_deq_ptr,
-                        &state->new_cycle_state);
+                        state->new_deq_ptr, &state->new_cycle_state);
         if (!state->new_deq_seg) {
                 WARN_ON(1);
                 return;
         }
 
+        /* Increment to find next TRB after last_trb. Cycle if appropriate. */
         trb = &state->new_deq_ptr->generic;
         if (TRB_TYPE_LINK_LE32(trb->field[3]) &&
             (trb->field[3] & cpu_to_le32(LINK_TOGGLE)))
                 state->new_cycle_state ^= 0x1;
         next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr);
 
-        /*
-         * If there is only one segment in a ring, find_trb_seg()'s while loop
-         * will not run, and it will return before it has a chance to see if it
-         * needs to toggle the cycle bit.  It can't tell if the stalled transfer
-         * ended just before the link TRB on a one-segment ring, or if the TD
-         * wrapped around the top of the ring, because it doesn't have the TD in
-         * question.  Look for the one-segment case where stalled TRB's address
-         * is greater than the new dequeue pointer address.
-         */
-        if (ep_ring->first_seg == ep_ring->first_seg->next &&
-                        state->new_deq_ptr < dev->eps[ep_index].stopped_trb)
-                state->new_cycle_state ^= 0x1;
+        /* Don't update the ring cycle state for the producer (us). */
         xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
                         "Cycle state = 0x%x", state->new_cycle_state);
 
-        /* Don't update the ring cycle state for the producer (us). */
         xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
                         "New dequeue segment = %p (virtual)",
                         state->new_deq_seg);
@@ -799,7 +801,6 @@ static void xhci_handle_cmd_stop_ep(struct xhci_hcd *xhci, int slot_id,
         if (list_empty(&ep->cancelled_td_list)) {
                 xhci_stop_watchdog_timer_in_irq(xhci, ep);
                 ep->stopped_td = NULL;
-                ep->stopped_trb = NULL;
                 ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
                 return;
         }
@@ -867,11 +868,9 @@ remove_finished_td:
                 ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
         }
 
-        /* Clear stopped_td and stopped_trb if endpoint is not halted */
-        if (!(ep->ep_state & EP_HALTED)) {
+        /* Clear stopped_td if endpoint is not halted */
+        if (!(ep->ep_state & EP_HALTED))
                 ep->stopped_td = NULL;
-                ep->stopped_trb = NULL;
-        }
 
         /*
          * Drop the lock and complete the URBs in the cancelled TD list.
@@ -1941,14 +1940,12 @@ static void xhci_cleanup_halted_endpoint(struct xhci_hcd *xhci,
         struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
         ep->ep_state |= EP_HALTED;
         ep->stopped_td = td;
-        ep->stopped_trb = event_trb;
         ep->stopped_stream = stream_id;
 
         xhci_queue_reset_ep(xhci, slot_id, ep_index);
         xhci_cleanup_stalled_ring(xhci, td->urb->dev, ep_index);
 
         ep->stopped_td = NULL;
-        ep->stopped_trb = NULL;
         ep->stopped_stream = 0;
 
         xhci_ring_cmd_db(xhci);
@@ -2030,7 +2027,6 @@ static int finish_td(struct xhci_hcd *xhci, struct xhci_td *td,
                  * the ring dequeue pointer or take this TD off any lists yet.
                  */
                 ep->stopped_td = td;
-                ep->stopped_trb = event_trb;
                 return 0;
         } else {
                 if (trb_comp_code == COMP_STALL) {
@@ -2042,7 +2038,6 @@ static int finish_td(struct xhci_hcd *xhci, struct xhci_td *td,
                          * USB class driver clear the stall later.
                          */
                         ep->stopped_td = td;
-                        ep->stopped_trb = event_trb;
                         ep->stopped_stream = ep_ring->stream_id;
                 } else if (xhci_requires_manual_halt_cleanup(xhci,
                                         ep_ctx, trb_comp_code)) {
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 8fe4e124ddd4..300836972faa 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -408,16 +408,16 @@ static int xhci_try_enable_msi(struct usb_hcd *hcd)
 
 #else
 
-static int xhci_try_enable_msi(struct usb_hcd *hcd)
+static inline int xhci_try_enable_msi(struct usb_hcd *hcd)
 {
         return 0;
 }
 
-static void xhci_cleanup_msix(struct xhci_hcd *xhci)
+static inline void xhci_cleanup_msix(struct xhci_hcd *xhci)
 {
 }
 
-static void xhci_msix_sync_irqs(struct xhci_hcd *xhci)
+static inline void xhci_msix_sync_irqs(struct xhci_hcd *xhci)
 {
 }
 
@@ -2954,7 +2954,6 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
                 xhci_ring_cmd_db(xhci);
         }
         virt_ep->stopped_td = NULL;
-        virt_ep->stopped_trb = NULL;
         virt_ep->stopped_stream = 0;
         spin_unlock_irqrestore(&xhci->lock, flags);
 
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index d280e9213d08..4746816aed3e 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -865,8 +865,6 @@ struct xhci_virt_ep {
 #define EP_GETTING_NO_STREAMS   (1 << 5)
         /* ----  Related to URB cancellation ---- */
         struct list_head        cancelled_td_list;
-        /* The TRB that was last reported in a stopped endpoint ring */
-        union xhci_trb          *stopped_trb;
         struct xhci_td          *stopped_td;
         unsigned int            stopped_stream;
         /* Watchdog timer for stop endpoint command to cancel URBs */