1 files changed, 88 insertions, 38 deletions

diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index b217456b0ac7..f0c557052f2f 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -66,7 +66,7 @@ static bool td_on_ring(struct xhci_td *td, struct xhci_ring *ring)
  * handshake done).  There are two failure modes:  "usec" have passed (major
  * hardware flakeout), or the register reads as all-ones (hardware removed).
  */
-int xhci_handshake(void __iomem *ptr, u32 mask, u32 done, int usec)
+int xhci_handshake(void __iomem *ptr, u32 mask, u32 done, u64 timeout_us)
 {
         u32     result;
         int     ret;
@@ -74,7 +74,7 @@ int xhci_handshake(void __iomem *ptr, u32 mask, u32 done, int usec)
         ret = readl_poll_timeout_atomic(ptr, result,
                                         (result & mask) == done ||
                                         result == U32_MAX,
-                                        1, usec);
+                                        1, timeout_us);
         if (result == U32_MAX)          /* card removed */
                 return -ENODEV;
 
@@ -163,7 +163,7 @@ int xhci_start(struct xhci_hcd *xhci)
  * Transactions will be terminated immediately, and operational registers
  * will be set to their defaults.
  */
-int xhci_reset(struct xhci_hcd *xhci)
+int xhci_reset(struct xhci_hcd *xhci, u64 timeout_us)
 {
         u32 command;
         u32 state;
@@ -196,8 +196,7 @@ int xhci_reset(struct xhci_hcd *xhci)
         if (xhci->quirks & XHCI_INTEL_HOST)
                 udelay(1000);
 
-        ret = xhci_handshake(&xhci->op_regs->command,
-                        CMD_RESET, 0, 10 * 1000 * 1000);
+        ret = xhci_handshake(&xhci->op_regs->command, CMD_RESET, 0, timeout_us);
         if (ret)
                 return ret;
 
@@ -210,8 +209,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 = xhci_handshake(&xhci->op_regs->status,
-                        STS_CNR, 0, 10 * 1000 * 1000);
+        ret = xhci_handshake(&xhci->op_regs->status, STS_CNR, 0, timeout_us);
 
         for (i = 0; i < 2; i++) {
                 xhci->bus_state[i].port_c_suspend = 0;
@@ -227,6 +225,7 @@ static void xhci_zero_64b_regs(struct xhci_hcd *xhci)
         struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
         int err, i;
         u64 val;
+        u32 intrs;
 
         /*
          * Some Renesas controllers get into a weird state if they are
@@ -265,7 +264,10 @@ static void xhci_zero_64b_regs(struct xhci_hcd *xhci)
         if (upper_32_bits(val))
                 xhci_write_64(xhci, 0, &xhci->op_regs->cmd_ring);
 
-        for (i = 0; i < HCS_MAX_INTRS(xhci->hcs_params1); i++) {
+        intrs = min_t(u32, HCS_MAX_INTRS(xhci->hcs_params1),
+                      ARRAY_SIZE(xhci->run_regs->ir_set));
+
+        for (i = 0; i < intrs; i++) {
                 struct xhci_intr_reg __iomem *ir;
 
                 ir = &xhci->run_regs->ir_set[i];
@@ -727,7 +729,7 @@ static void xhci_stop(struct usb_hcd *hcd)
         xhci->xhc_state |= XHCI_STATE_HALTED;
         xhci->cmd_ring_state = CMD_RING_STATE_STOPPED;
         xhci_halt(xhci);
-        xhci_reset(xhci);
+        xhci_reset(xhci, XHCI_RESET_SHORT_USEC);
         spin_unlock_irq(&xhci->lock);
 
         xhci_cleanup_msix(xhci);
@@ -776,11 +778,22 @@ void xhci_shutdown(struct usb_hcd *hcd)
         if (xhci->quirks & XHCI_SPURIOUS_REBOOT)
                 usb_disable_xhci_ports(to_pci_dev(hcd->self.sysdev));
 
+        /* Don't poll the roothubs after shutdown. */
+        xhci_dbg(xhci, "%s: stopping usb%d port polling.\n",
+                        __func__, hcd->self.busnum);
+        clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+        del_timer_sync(&hcd->rh_timer);
+
+        if (xhci->shared_hcd) {
+                clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
+                del_timer_sync(&xhci->shared_hcd->rh_timer);
+        }
+
         spin_lock_irq(&xhci->lock);
         xhci_halt(xhci);
         /* Workaround for spurious wakeups at shutdown with HSW */
         if (xhci->quirks & XHCI_SPURIOUS_WAKEUP)
-                xhci_reset(xhci);
+                xhci_reset(xhci, XHCI_RESET_SHORT_USEC);
         spin_unlock_irq(&xhci->lock);
 
         xhci_cleanup_msix(xhci);
@@ -1078,6 +1091,8 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
         struct usb_hcd          *secondary_hcd;
         int                     retval = 0;
         bool                    comp_timer_running = false;
+        bool                    pending_portevent = false;
+        bool                    reinit_xhc = false;
 
         if (!hcd->state)
                 return 0;
@@ -1094,10 +1109,11 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
         set_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
 
         spin_lock_irq(&xhci->lock);
-        if ((xhci->quirks & XHCI_RESET_ON_RESUME) || xhci->broken_suspend)
-                hibernated = true;
 
-        if (!hibernated) {
+        if (hibernated || xhci->quirks & XHCI_RESET_ON_RESUME || xhci->broken_suspend)
+                reinit_xhc = true;
+
+        if (!reinit_xhc) {
                 /*
                  * Some controllers might lose power during suspend, so wait
                  * for controller not ready bit to clear, just as in xHC init.
@@ -1130,12 +1146,17 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                         spin_unlock_irq(&xhci->lock);
                         return -ETIMEDOUT;
                 }
-                temp = readl(&xhci->op_regs->status);
         }
 
-        /* If restore operation fails, re-initialize the HC during resume */
-        if ((temp & STS_SRE) || hibernated) {
+        temp = readl(&xhci->op_regs->status);
+
+        /* re-initialize the HC on Restore Error, or Host Controller Error */
+        if (temp & (STS_SRE | STS_HCE)) {
+                reinit_xhc = true;
+                xhci_warn(xhci, "xHC error in resume, USBSTS 0x%x, Reinit\n", temp);
+        }
 
+        if (reinit_xhc) {
                 if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) &&
                                 !(xhci_all_ports_seen_u0(xhci))) {
                         del_timer_sync(&xhci->comp_mode_recovery_timer);
@@ -1150,7 +1171,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                 xhci_dbg(xhci, "Stop HCD\n");
                 xhci_halt(xhci);
                 xhci_zero_64b_regs(xhci);
-                retval = xhci_reset(xhci);
+                retval = xhci_reset(xhci, XHCI_RESET_LONG_USEC);
                 spin_unlock_irq(&xhci->lock);
                 if (retval)
                         return retval;
@@ -1216,13 +1237,22 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
 
  done:
         if (retval == 0) {
-                /* Resume root hubs only when have pending events. */
-                if (xhci_pending_portevent(xhci)) {
+                /*
+                 * Resume roothubs only if there are pending events.
+                 * USB 3 devices resend U3 LFPS wake after a 100ms delay if
+                 * the first wake signalling failed, give it that chance.
+                 */
+                pending_portevent = xhci_pending_portevent(xhci);
+                if (!pending_portevent) {
+                        msleep(120);
+                        pending_portevent = xhci_pending_portevent(xhci);
+                }
+
+                if (pending_portevent) {
                         usb_hcd_resume_root_hub(xhci->shared_hcd);
                         usb_hcd_resume_root_hub(hcd);
                 }
         }
-
         /*
          * If system is subject to the Quirk, Compliance Mode Timer needs to
          * be re-initialized Always after a system resume. Ports are subject
@@ -1360,7 +1390,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
  * we need to issue an evaluate context command and wait on it.
  */
 static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
-                unsigned int ep_index, struct urb *urb)
+                unsigned int ep_index, struct urb *urb, gfp_t mem_flags)
 {
         struct xhci_container_ctx *out_ctx;
         struct xhci_input_control_ctx *ctrl_ctx;
@@ -1391,7 +1421,7 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                  * changes max packet sizes.
                  */
 
-                command = xhci_alloc_command(xhci, true, GFP_KERNEL);
+                command = xhci_alloc_command(xhci, true, mem_flags);
                 if (!command)
                         return -ENOMEM;
 
@@ -1443,9 +1473,12 @@ static int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flag
         struct urb_priv *urb_priv;
         int num_tds;
 
-        if (!urb || xhci_check_args(hcd, urb->dev, urb->ep,
-                                        true, true, __func__) <= 0)
+        if (!urb)
                 return -EINVAL;
+        ret = xhci_check_args(hcd, urb->dev, urb->ep,
+                                        true, true, __func__);
+        if (ret <= 0)
+                return ret ? ret : -EINVAL;
 
         slot_id = urb->dev->slot_id;
         ep_index = xhci_get_endpoint_index(&urb->ep->desc);
@@ -1488,7 +1521,7 @@ static int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flag
                  */
                 if (urb->dev->speed == USB_SPEED_FULL) {
                         ret = xhci_check_maxpacket(xhci, slot_id,
-                                        ep_index, urb);
+                                        ep_index, urb, mem_flags);
                         if (ret < 0) {
                                 xhci_urb_free_priv(urb_priv);
                                 urb->hcpriv = NULL;
@@ -3079,10 +3112,13 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd,
         ep = &vdev->eps[ep_index];
 
         /* Bail out if toggle is already being cleared by a endpoint reset */
+        spin_lock_irqsave(&xhci->lock, flags);
         if (ep->ep_state & EP_HARD_CLEAR_TOGGLE) {
                 ep->ep_state &= ~EP_HARD_CLEAR_TOGGLE;
+                spin_unlock_irqrestore(&xhci->lock, flags);
                 return;
         }
+        spin_unlock_irqrestore(&xhci->lock, flags);
         /* Only interrupt and bulk ep's use data toggle, USB2 spec 5.5.4-> */
         if (usb_endpoint_xfer_control(&host_ep->desc) ||
             usb_endpoint_xfer_isoc(&host_ep->desc))
@@ -3138,6 +3174,14 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd,
 
         /* config ep command clears toggle if add and drop ep flags are set */
         ctrl_ctx = xhci_get_input_control_ctx(cfg_cmd->in_ctx);
+        if (!ctrl_ctx) {
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                xhci_free_command(xhci, cfg_cmd);
+                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
+                                __func__);
+                goto cleanup;
+        }
+
         xhci_setup_input_ctx_for_config_ep(xhci, cfg_cmd->in_ctx, vdev->out_ctx,
                                            ctrl_ctx, ep_flag, ep_flag);
         xhci_endpoint_copy(xhci, cfg_cmd->in_ctx, vdev->out_ctx, ep_index);
@@ -3160,8 +3204,10 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd,
         xhci_free_command(xhci, cfg_cmd);
 cleanup:
         xhci_free_command(xhci, stop_cmd);
+        spin_lock_irqsave(&xhci->lock, flags);
         if (ep->ep_state & EP_SOFT_CLEAR_TOGGLE)
                 ep->ep_state &= ~EP_SOFT_CLEAR_TOGGLE;
+        spin_unlock_irqrestore(&xhci->lock, flags);
 }
 
 static int xhci_check_streams_endpoint(struct xhci_hcd *xhci,
@@ -3176,7 +3222,7 @@ static int xhci_check_streams_endpoint(struct xhci_hcd *xhci,
                 return -EINVAL;
         ret = xhci_check_args(xhci_to_hcd(xhci), udev, ep, 1, true, __func__);
         if (ret <= 0)
-                return -EINVAL;
+                return ret ? ret : -EINVAL;
         if (usb_ss_max_streams(&ep->ss_ep_comp) == 0) {
                 xhci_warn(xhci, "WARN: SuperSpeed Endpoint Companion"
                                 " descriptor for ep 0x%x does not support streams\n",
@@ -3783,7 +3829,6 @@ static void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         struct xhci_slot_ctx *slot_ctx;
         int i, ret;
 
-#ifndef CONFIG_USB_DEFAULT_PERSIST
         /*
          * We called pm_runtime_get_noresume when the device was attached.
          * Decrement the counter here to allow controller to runtime suspend
@@ -3791,7 +3836,6 @@ static void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
          */
         if (xhci->quirks & XHCI_RESET_ON_RESUME)
                 pm_runtime_put_noidle(hcd->self.controller);
-#endif
 
         ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
         /* If the host is halted due to driver unload, we still need to free the
@@ -3811,9 +3855,8 @@ static void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         }
         xhci_debugfs_remove_slot(xhci, udev->slot_id);
         virt_dev->udev = NULL;
-        ret = xhci_disable_slot(xhci, udev->slot_id);
-        if (ret)
-                xhci_free_virt_device(xhci, udev->slot_id);
+        xhci_disable_slot(xhci, udev->slot_id);
+        xhci_free_virt_device(xhci, udev->slot_id);
 }
 
 int xhci_disable_slot(struct xhci_hcd *xhci, u32 slot_id)
@@ -3823,7 +3866,7 @@ int xhci_disable_slot(struct xhci_hcd *xhci, u32 slot_id)
         u32 state;
         int ret = 0;
 
-        command = xhci_alloc_command(xhci, false, GFP_KERNEL);
+        command = xhci_alloc_command(xhci, true, GFP_KERNEL);
         if (!command)
                 return -ENOMEM;
 
@@ -3846,6 +3889,15 @@ int xhci_disable_slot(struct xhci_hcd *xhci, u32 slot_id)
         }
         xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
+
+        wait_for_completion(command->completion);
+
+        if (command->status != COMP_SUCCESS)
+                xhci_warn(xhci, "Unsuccessful disable slot %u command, status %d\n",
+                          slot_id, command->status);
+
+        xhci_free_command(xhci, command);
+
         return ret;
 }
 
@@ -3942,23 +3994,20 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
 
         xhci_debugfs_create_slot(xhci, slot_id);
 
-#ifndef CONFIG_USB_DEFAULT_PERSIST
         /*
          * If resetting upon resume, we can't put the controller into runtime
          * suspend if there is a device attached.
          */
         if (xhci->quirks & XHCI_RESET_ON_RESUME)
                 pm_runtime_get_noresume(hcd->self.controller);
-#endif
 
         /* Is this a LS or FS device under a HS hub? */
         /* Hub or peripherial? */
         return 1;
 
 disable_slot:
-        ret = xhci_disable_slot(xhci, udev->slot_id);
-        if (ret)
-                xhci_free_virt_device(xhci, udev->slot_id);
+        xhci_disable_slot(xhci, udev->slot_id);
+        xhci_free_virt_device(xhci, udev->slot_id);
 
         return 0;
 }
@@ -4087,6 +4136,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
 
                 mutex_unlock(&xhci->mutex);
                 ret = xhci_disable_slot(xhci, udev->slot_id);
+                xhci_free_virt_device(xhci, udev->slot_id);
                 if (!ret)
                         xhci_alloc_dev(hcd, udev);
                 kfree(command->completion);
@@ -5149,7 +5199,7 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
 
         xhci_dbg(xhci, "Resetting HCD\n");
         /* Reset the internal HC memory state and registers. */
-        retval = xhci_reset(xhci);
+        retval = xhci_reset(xhci, XHCI_RESET_LONG_USEC);
         if (retval)
                 return retval;
         xhci_dbg(xhci, "Reset complete\n");