usb: xhci: optimize resuming from S4 (suspend-to-disk)

On resume from S4 (power loss after suspend/hibernation), the xHCI
driver previously freed, reallocated, and fully reinitialized all
data structures. Most of this is unnecessary because the data is
restored from a saved image; only the xHCI registers lose their values.

This patch optimizes S4 resume by performing only a host controller
reset, which includes:
* Freeing or clearing runtime-created data.
* Rewriting xHCI registers.

Signed-off-by: Niklas Neronin <niklas.neronin@linux.intel.com>
Signed-off-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Link: https://patch.msgid.link/20260402131342.2628648-13-mathias.nyman@linux.intel.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index f1b4f06d4b8b8013ab16ccb585b123dc48c5073b..4156822eb0001fda7ee1edd13ad49d879e6981f3 100644 (file)
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -936,7 +936,7 @@ void xhci_free_virt_device(struct xhci_hcd *xhci, struct xhci_virt_device *dev,
  * that tt_info, then free the child first. Recursive.
  * We can't rely on udev at this point to find child-parent relationships.
  */
-static void xhci_free_virt_devices_depth_first(struct xhci_hcd *xhci, int slot_id)
+void xhci_free_virt_devices_depth_first(struct xhci_hcd *xhci, int slot_id)
 {
        struct xhci_virt_device *vdev;
        struct list_head *tt_list_head;
@@ -1905,7 +1905,7 @@ void xhci_remove_secondary_interrupter(struct usb_hcd *hcd, struct xhci_interrup
 EXPORT_SYMBOL_GPL(xhci_remove_secondary_interrupter);
 
 /* Cleanup roothub bandwidth data */
-static void xhci_rh_bw_cleanup(struct xhci_hcd *xhci)
+void xhci_rh_bw_cleanup(struct xhci_hcd *xhci)
 {
        struct xhci_root_port_bw_info *rh_bw;
        struct xhci_tt_bw_info *tt_info, *tt_next;

diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 2c573aad4464ae9a137e8ec789e5d1b89a57fda4..ece3ff7916fffba10d58bc088e8375d8e137e58e 100644 (file)
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -1082,9 +1082,11 @@ int xhci_resume(struct xhci_hcd *xhci, bool power_lost, bool is_auto_resume)
 {
        u32                     command, temp = 0;
        struct usb_hcd          *hcd = xhci_to_hcd(xhci);
+       struct xhci_segment     *seg;
        int                     retval = 0;
        bool                    pending_portevent = false;
        bool                    suspended_usb3_devs = false;
+       bool                    reset_registers = false;
 
        if (!hcd->state)
                return 0;
@@ -1103,10 +1105,11 @@ int xhci_resume(struct xhci_hcd *xhci, bool power_lost, bool is_auto_resume)
 
        spin_lock_irq(&xhci->lock);
 
-       if (xhci->quirks & XHCI_RESET_ON_RESUME || xhci->broken_suspend)
-               power_lost = true;
-
-       if (!power_lost) {
+       if (power_lost || xhci->broken_suspend || xhci->quirks & XHCI_RESET_ON_RESUME) {
+               xhci_dbg(xhci, "HC state lost, performing host controller reset\n");
+               reset_registers = true;
+       } else {
+               xhci_dbg(xhci, "HC state intact, continuing without reset\n");
                /*
                 * Some controllers might lose power during suspend, so wait
                 * for controller not ready bit to clear, just as in xHC init.
@@ -1144,11 +1147,11 @@ int xhci_resume(struct xhci_hcd *xhci, bool power_lost, bool is_auto_resume)
                temp = readl(&xhci->op_regs->status);
                if ((temp & (STS_SRE | STS_HCE)) && !(xhci->xhc_state & XHCI_STATE_REMOVING)) {
                        xhci_warn(xhci, "xHC error in resume, USBSTS 0x%x, Reinit\n", temp);
-                       power_lost = true;
+                       reset_registers = true;
                }
        }
 
-       if (power_lost) {
+       if (reset_registers) {
                if ((xhci->quirks & XHCI_COMP_MODE_QUIRK) &&
                                !(xhci_all_ports_seen_u0(xhci))) {
                        timer_delete_sync(&xhci->comp_mode_recovery_timer);
@@ -1172,27 +1175,33 @@ int xhci_resume(struct xhci_hcd *xhci, bool power_lost, bool is_auto_resume)
                if (retval)
                        return retval;
 
-               xhci_dbg(xhci, "// Disabling event ring interrupts\n");
-               temp = readl(&xhci->op_regs->status);
-               writel((temp & ~0x1fff) | STS_EINT, &xhci->op_regs->status);
-               xhci_disable_interrupter(xhci, xhci->interrupters[0]);
+               cancel_delayed_work_sync(&xhci->cmd_timer);
+
+               /* Delete all remaining commands */
+               xhci_cleanup_command_queue(xhci);
+
+               /* Clear data which is re-initilized during runtime */
+               xhci_for_each_ring_seg(xhci->interrupters[0]->event_ring->first_seg, seg)
+                       memset(seg->trbs, 0, sizeof(union xhci_trb) * TRBS_PER_SEGMENT);
+
+               for (int i = xhci->max_slots; i > 0; i--)
+                       xhci_free_virt_devices_depth_first(xhci, i);
+
+               xhci_rh_bw_cleanup(xhci);
+
+               xhci->cmd_ring_reserved_trbs = 0;
+               xhci_for_each_ring_seg(xhci->cmd_ring->first_seg, seg)
+                       memset(seg->trbs, 0, sizeof(union xhci_trb) * TRBS_PER_SEGMENT);
 
-               xhci_dbg(xhci, "cleaning up memory\n");
-               xhci_mem_cleanup(xhci);
                xhci_debugfs_exit(xhci);
-               xhci_dbg(xhci, "xhci_stop completed - status = %x\n",
-                           readl(&xhci->op_regs->status));
 
-               /* USB core calls the PCI reinit and start functions twice:
+               xhci_init(hcd);
+
+               /*
+                * USB core calls the PCI reinit and start functions twice:
                 * first with the primary HCD, and then with the secondary HCD.
                 * If we don't do the same, the host will never be started.
                 */
-               retval = xhci_mem_init(xhci, GFP_KERNEL);
-               if (retval)
-                       return retval;
-
-               xhci_init(hcd);
-
                xhci_dbg(xhci, "Start the primary HCD\n");
                retval = xhci_run(hcd);
                if (!retval && xhci->shared_hcd) {

diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 06f6da4d982fc7d29d6d418c30355b7101ad1b4c..aeecd301f20707117d35b680e9f243458530e219 100644 (file)
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1793,6 +1793,7 @@ void xhci_dbg_trace(struct xhci_hcd *xhci, void (*trace)(struct va_format *),
 void xhci_mem_cleanup(struct xhci_hcd *xhci);
 int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags);
 void xhci_free_virt_device(struct xhci_hcd *xhci, struct xhci_virt_device *dev, int slot_id);
+void xhci_free_virt_devices_depth_first(struct xhci_hcd *xhci, int slot_id);
 int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, struct usb_device *udev, gfp_t flags);
 int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *udev);
 void xhci_copy_ep0_dequeue_into_input_ctx(struct xhci_hcd *xhci,
@@ -1804,6 +1805,7 @@ void xhci_update_tt_active_eps(struct xhci_hcd *xhci,
                struct xhci_virt_device *virt_dev,
                int old_active_eps);
 void xhci_clear_endpoint_bw_info(struct xhci_bw_info *bw_info);
+void xhci_rh_bw_cleanup(struct xhci_hcd *xhci);
 void xhci_update_bw_info(struct xhci_hcd *xhci,
                struct xhci_container_ctx *in_ctx,
                struct xhci_input_control_ctx *ctrl_ctx,