1 files changed, 19 insertions, 13 deletions

diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index c9e419f29b74..5c72c431bab1 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -40,7 +40,7 @@ MODULE_PARM_DESC(link_quirk, "Don't clear the chain bit on a link TRB");
 
 /* TODO: copied from ehci-hcd.c - can this be refactored? */
 /*
- * handshake - spin reading hc until handshake completes or fails
+ * xhci_handshake - spin reading hc until handshake completes or fails
  * @ptr: address of hc register to be read
  * @mask: bits to look at in result of read
  * @done: value of those bits when handshake succeeds
@@ -52,7 +52,7 @@ MODULE_PARM_DESC(link_quirk, "Don't clear the chain bit on a link TRB");
  * handshake done).  There are two failure modes:  "usec" have passed (major
  * hardware flakeout), or the register reads as all-ones (hardware removed).
  */
-int handshake(struct xhci_hcd *xhci, void __iomem *ptr,
+int xhci_handshake(struct xhci_hcd *xhci, void __iomem *ptr,
                       u32 mask, u32 done, int usec)
 {
         u32     result;
@@ -103,7 +103,7 @@ int xhci_halt(struct xhci_hcd *xhci)
         xhci_dbg(xhci, "// Halt the HC\n");
         xhci_quiesce(xhci);
 
-        ret = handshake(xhci, &xhci->op_regs->status,
+        ret = xhci_handshake(xhci, &xhci->op_regs->status,
                         STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC);
         if (!ret) {
                 xhci->xhc_state |= XHCI_STATE_HALTED;
@@ -132,7 +132,7 @@ static int xhci_start(struct xhci_hcd *xhci)
          * Wait for the HCHalted Status bit to be 0 to indicate the host is
          * running.
          */
-        ret = handshake(xhci, &xhci->op_regs->status,
+        ret = xhci_handshake(xhci, &xhci->op_regs->status,
                         STS_HALT, 0, XHCI_MAX_HALT_USEC);
         if (ret == -ETIMEDOUT)
                 xhci_err(xhci, "Host took too long to start, "
@@ -167,7 +167,7 @@ int xhci_reset(struct xhci_hcd *xhci)
         command |= CMD_RESET;
         xhci_writel(xhci, command, &xhci->op_regs->command);
 
-        ret = handshake(xhci, &xhci->op_regs->command,
+        ret = xhci_handshake(xhci, &xhci->op_regs->command,
                         CMD_RESET, 0, 10 * 1000 * 1000);
         if (ret)
                 return ret;
@@ -177,7 +177,7 @@ int xhci_reset(struct xhci_hcd *xhci)
          * xHCI cannot write to any doorbells or operational registers other
          * than status until the "Controller Not Ready" flag is cleared.
          */
-        ret = handshake(xhci, &xhci->op_regs->status,
+        ret = xhci_handshake(xhci, &xhci->op_regs->status,
                         STS_CNR, 0, 10 * 1000 * 1000);
 
         for (i = 0; i < 2; ++i) {
@@ -480,7 +480,7 @@ static bool compliance_mode_recovery_timer_quirk_check(void)
         if (strstr(dmi_product_name, "Z420") ||
                         strstr(dmi_product_name, "Z620") ||
                         strstr(dmi_product_name, "Z820") ||
-                        strstr(dmi_product_name, "Z1"))
+                        strstr(dmi_product_name, "Z1 Workstation"))
                 return true;
 
         return false;
@@ -880,6 +880,10 @@ int xhci_suspend(struct xhci_hcd *xhci)
         struct usb_hcd          *hcd = xhci_to_hcd(xhci);
         u32                     command;
 
+        if (hcd->state != HC_STATE_SUSPENDED ||
+                        xhci->shared_hcd->state != HC_STATE_SUSPENDED)
+                return -EINVAL;
+
         spin_lock_irq(&xhci->lock);
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
@@ -890,7 +894,7 @@ int xhci_suspend(struct xhci_hcd *xhci)
         command = xhci_readl(xhci, &xhci->op_regs->command);
         command &= ~CMD_RUN;
         xhci_writel(xhci, command, &xhci->op_regs->command);
-        if (handshake(xhci, &xhci->op_regs->status,
+        if (xhci_handshake(xhci, &xhci->op_regs->status,
                       STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC)) {
                 xhci_warn(xhci, "WARN: xHC CMD_RUN timeout\n");
                 spin_unlock_irq(&xhci->lock);
@@ -905,7 +909,8 @@ int xhci_suspend(struct xhci_hcd *xhci)
         command = xhci_readl(xhci, &xhci->op_regs->command);
         command |= CMD_CSS;
         xhci_writel(xhci, command, &xhci->op_regs->command);
-        if (handshake(xhci, &xhci->op_regs->status, STS_SAVE, 0, 10 * 1000)) {
+        if (xhci_handshake(xhci, &xhci->op_regs->status,
+                                STS_SAVE, 0, 10 * 1000)) {
                 xhci_warn(xhci, "WARN: xHC save state timeout\n");
                 spin_unlock_irq(&xhci->lock);
                 return -ETIMEDOUT;
@@ -967,7 +972,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                 command = xhci_readl(xhci, &xhci->op_regs->command);
                 command |= CMD_CRS;
                 xhci_writel(xhci, command, &xhci->op_regs->command);
-                if (handshake(xhci, &xhci->op_regs->status,
+                if (xhci_handshake(xhci, &xhci->op_regs->status,
                               STS_RESTORE, 0, 10 * 1000)) {
                         xhci_warn(xhci, "WARN: xHC restore state timeout\n");
                         spin_unlock_irq(&xhci->lock);
@@ -1035,7 +1040,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
         command = xhci_readl(xhci, &xhci->op_regs->command);
         command |= CMD_RUN;
         xhci_writel(xhci, command, &xhci->op_regs->command);
-        handshake(xhci, &xhci->op_regs->status, STS_HALT,
+        xhci_handshake(xhci, &xhci->op_regs->status, STS_HALT,
                   0, 250 * 1000);
 
         /* step 5: walk topology and initialize portsc,
@@ -2254,7 +2259,7 @@ static bool xhci_is_async_ep(unsigned int ep_type)
 
 static bool xhci_is_sync_in_ep(unsigned int ep_type)
 {
-        return (ep_type == ISOC_IN_EP || ep_type != INT_IN_EP);
+        return (ep_type == ISOC_IN_EP || ep_type == INT_IN_EP);
 }
 
 static unsigned int xhci_get_ss_bw_consumed(struct xhci_bw_info *ep_bw)
@@ -3874,7 +3879,8 @@ static int xhci_usb2_software_lpm_test(struct usb_hcd *hcd,
         spin_lock_irqsave(&xhci->lock, flags);
 
         /* Check L1 Status */
-        ret = handshake(xhci, pm_addr, PORT_L1S_MASK, PORT_L1S_SUCCESS, 125);
+        ret = xhci_handshake(xhci, pm_addr,
+                        PORT_L1S_MASK, PORT_L1S_SUCCESS, 125);
         if (ret != -ETIMEDOUT) {
                 /* enter L1 successfully */
                 temp = xhci_readl(xhci, addr);