7 files changed, 84 insertions, 29 deletions

diff --git a/drivers/usb/host/xhci-mtk-sch.c b/drivers/usb/host/xhci-mtk-sch.c
index c30de7c39f44..73f763c4f5f5 100644
--- a/drivers/usb/host/xhci-mtk-sch.c
+++ b/drivers/usb/host/xhci-mtk-sch.c
@@ -275,8 +275,9 @@ static bool need_bw_sch(struct usb_host_endpoint *ep,
                 return false;
 
         /*
-         * for LS & FS periodic endpoints which its device don't attach
-         * to TT are also ignored, root-hub will schedule them directly
+         * for LS & FS periodic endpoints which its device is not behind
+         * a TT are also ignored, root-hub will schedule them directly,
+         * but need set @bpkts field of endpoint context to 1.
          */
         if (is_fs_or_ls(speed) && !has_tt)
                 return false;
@@ -339,8 +340,17 @@ int xhci_mtk_add_ep_quirk(struct usb_hcd *hcd, struct usb_device *udev,
                 GET_MAX_PACKET(usb_endpoint_maxp(&ep->desc)),
                 usb_endpoint_dir_in(&ep->desc), ep);
 
-        if (!need_bw_sch(ep, udev->speed, slot_ctx->tt_info & TT_SLOT))
+        if (!need_bw_sch(ep, udev->speed, slot_ctx->tt_info & TT_SLOT)) {
+                /*
+                 * set @bpkts to 1 if it is LS or FS periodic endpoint, and its
+                 * device does not connected through an external HS hub
+                 */
+                if (usb_endpoint_xfer_int(&ep->desc)
+                        || usb_endpoint_xfer_isoc(&ep->desc))
+                        ep_ctx->reserved[0] |= cpu_to_le32(EP_BPKTS(1));
+
                 return 0;
+        }
 
         bw_index = get_bw_index(xhci, udev, ep);
         sch_bw = &sch_array[bw_index];
diff --git a/drivers/usb/host/xhci-mtk.c b/drivers/usb/host/xhci-mtk.c
index c9ab6a44c34a..9532f5aef71b 100644
--- a/drivers/usb/host/xhci-mtk.c
+++ b/drivers/usb/host/xhci-mtk.c
@@ -696,9 +696,24 @@ static int xhci_mtk_remove(struct platform_device *dev)
 }
 
 #ifdef CONFIG_PM_SLEEP
+/*
+ * if ip sleep fails, and all clocks are disabled, access register will hang
+ * AHB bus, so stop polling roothubs to avoid regs access on bus suspend.
+ * and no need to check whether ip sleep failed or not; this will cause SPM
+ * to wake up system immediately after system suspend complete if ip sleep
+ * fails, it is what we wanted.
+ */
 static int xhci_mtk_suspend(struct device *dev)
 {
         struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev);
+        struct usb_hcd *hcd = mtk->hcd;
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+
+        xhci_dbg(xhci, "%s: stop port polling\n", __func__);
+        clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+        del_timer_sync(&hcd->rh_timer);
+        clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
+        del_timer_sync(&xhci->shared_hcd->rh_timer);
 
         xhci_mtk_host_disable(mtk);
         xhci_mtk_phy_power_off(mtk);
@@ -710,11 +725,19 @@ static int xhci_mtk_suspend(struct device *dev)
 static int xhci_mtk_resume(struct device *dev)
 {
         struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev);
+        struct usb_hcd *hcd = mtk->hcd;
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 
         usb_wakeup_disable(mtk);
         xhci_mtk_clks_enable(mtk);
         xhci_mtk_phy_power_on(mtk);
         xhci_mtk_host_enable(mtk);
+
+        xhci_dbg(xhci, "%s: restart port polling\n", __func__);
+        set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+        usb_hcd_poll_rh_status(hcd);
+        set_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
+        usb_hcd_poll_rh_status(xhci->shared_hcd);
         return 0;
 }
 
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 58c43ed7ff3b..f0640b7a1c42 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -28,7 +28,9 @@
 #include "xhci.h"
 #include "xhci-trace.h"
 
-#define PORT2_SSIC_CONFIG_REG2  0x883c
+#define SSIC_PORT_NUM           2
+#define SSIC_PORT_CFG2          0x880c
+#define SSIC_PORT_CFG2_OFFSET   0x30
 #define PROG_DONE               (1 << 30)
 #define SSIC_PORT_UNUSED        (1 << 31)
 
@@ -45,6 +47,7 @@
 #define PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI             0x22b5
 #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_XHCI         0xa12f
 #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI        0x9d2f
+#define PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI              0x0aa8
 
 static const char hcd_name[] = "xhci_hcd";
 
@@ -151,9 +154,14 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
         if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
                 (pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI ||
                  pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_XHCI ||
-                 pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI)) {
+                 pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI ||
+                 pdev->device == PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI)) {
                 xhci->quirks |= XHCI_PME_STUCK_QUIRK;
         }
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                 pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI) {
+                xhci->quirks |= XHCI_SSIC_PORT_UNUSED;
+        }
         if (pdev->vendor == PCI_VENDOR_ID_ETRON &&
                         pdev->device == PCI_DEVICE_ID_EJ168) {
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
@@ -312,22 +320,20 @@ static void xhci_pci_remove(struct pci_dev *dev)
  * SSIC PORT need to be marked as "unused" before putting xHCI
  * into D3. After D3 exit, the SSIC port need to be marked as "used".
  * Without this change, xHCI might not enter D3 state.
- * Make sure PME works on some Intel xHCI controllers by writing 1 to clear
- * the Internal PME flag bit in vendor specific PMCTRL register at offset 0x80a4
  */
-static void xhci_pme_quirk(struct usb_hcd *hcd, bool suspend)
+static void xhci_ssic_port_unused_quirk(struct usb_hcd *hcd, bool suspend)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
-        struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
         u32 val;
         void __iomem *reg;
+        int i;
 
-        if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
-                 pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI) {
-
-                reg = (void __iomem *) xhci->cap_regs + PORT2_SSIC_CONFIG_REG2;
+        for (i = 0; i < SSIC_PORT_NUM; i++) {
+                reg = (void __iomem *) xhci->cap_regs +
+                                SSIC_PORT_CFG2 +
+                                i * SSIC_PORT_CFG2_OFFSET;
 
-                /* Notify SSIC that SSIC profile programming is not done */
+                /* Notify SSIC that SSIC profile programming is not done. */
                 val = readl(reg) & ~PROG_DONE;
                 writel(val, reg);
 
@@ -344,6 +350,17 @@ static void xhci_pme_quirk(struct usb_hcd *hcd, bool suspend)
                 writel(val, reg);
                 readl(reg);
         }
+}
+
+/*
+ * Make sure PME works on some Intel xHCI controllers by writing 1 to clear
+ * the Internal PME flag bit in vendor specific PMCTRL register at offset 0x80a4
+ */
+static void xhci_pme_quirk(struct usb_hcd *hcd)
+{
+        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        void __iomem *reg;
+        u32 val;
 
         reg = (void __iomem *) xhci->cap_regs + 0x80a4;
         val = readl(reg);
@@ -355,6 +372,7 @@ static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
+        int                     ret;
 
         /*
          * Systems with the TI redriver that loses port status change events
@@ -364,9 +382,16 @@ static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
                 pdev->no_d3cold = true;
 
         if (xhci->quirks & XHCI_PME_STUCK_QUIRK)
-                xhci_pme_quirk(hcd, true);
+                xhci_pme_quirk(hcd);
+
+        if (xhci->quirks & XHCI_SSIC_PORT_UNUSED)
+                xhci_ssic_port_unused_quirk(hcd, true);
 
-        return xhci_suspend(xhci, do_wakeup);
+        ret = xhci_suspend(xhci, do_wakeup);
+        if (ret && (xhci->quirks & XHCI_SSIC_PORT_UNUSED))
+                xhci_ssic_port_unused_quirk(hcd, false);
+
+        return ret;
 }
 
 static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
@@ -396,8 +421,11 @@ static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
         if (pdev->vendor == PCI_VENDOR_ID_INTEL)
                 usb_enable_intel_xhci_ports(pdev);
 
+        if (xhci->quirks & XHCI_SSIC_PORT_UNUSED)
+                xhci_ssic_port_unused_quirk(hcd, false);
+
         if (xhci->quirks & XHCI_PME_STUCK_QUIRK)
-                xhci_pme_quirk(hcd, false);
+                xhci_pme_quirk(hcd);
 
         retval = xhci_resume(xhci, hibernated);
         return retval;
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 770b6b088797..d39d6bf1d090 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -184,7 +184,8 @@ static int xhci_plat_probe(struct platform_device *pdev)
                 struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
 
                 /* Just copy data for now */
-                *priv = *priv_match;
+                if (priv_match)
+                        *priv = *priv_match;
         }
 
         if (xhci_plat_type_is(hcd, XHCI_PLAT_TYPE_MARVELL_ARMADA)) {
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index f1c21c40b4a6..3915657e6078 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -2193,10 +2193,6 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 }
         /* Fast path - was this the last TRB in the TD for this URB? */
         } else if (event_trb == td->last_trb) {
-                if (td->urb_length_set && trb_comp_code == COMP_SHORT_TX)
-                        return finish_td(xhci, td, event_trb, event, ep,
-                                         status, false);
-
                 if (EVENT_TRB_LEN(le32_to_cpu(event->transfer_len)) != 0) {
                         td->urb->actual_length =
                                 td->urb->transfer_buffer_length -
@@ -2248,12 +2244,6 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                         td->urb->actual_length +=
                                 TRB_LEN(le32_to_cpu(cur_trb->generic.field[2])) -
                                 EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));
-
-                if (trb_comp_code == COMP_SHORT_TX) {
-                        xhci_dbg(xhci, "mid bulk/intr SP, wait for last TRB event\n");
-                        td->urb_length_set = true;
-                        return 0;
-                }
         }
 
         return finish_td(xhci, td, event_trb, event, ep, status, false);
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 26a44c0e969e..0c8087d3c313 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -1554,7 +1554,9 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                 xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
                                 "HW died, freeing TD.");
                 urb_priv = urb->hcpriv;
-                for (i = urb_priv->td_cnt; i < urb_priv->length; i++) {
+                for (i = urb_priv->td_cnt;
+                     i < urb_priv->length && xhci->devs[urb->dev->slot_id];
+                     i++) {
                         td = urb_priv->td[i];
                         if (!list_empty(&td->td_list))
                                 list_del_init(&td->td_list);
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 9be7348872ba..cc651383ce5a 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1631,6 +1631,7 @@ struct xhci_hcd {
 #define XHCI_BROKEN_STREAMS     (1 << 19)
 #define XHCI_PME_STUCK_QUIRK    (1 << 20)
 #define XHCI_MTK_HOST           (1 << 21)
+#define XHCI_SSIC_PORT_UNUSED   (1 << 22)
         unsigned int            num_active_eps;
         unsigned int            limit_active_eps;
         /* There are two roothubs to keep track of bus suspend info for */