usb: xhci: relocate pre-allocation initialization

Move pre-allocation initialization from xhci_mem_init() to xhci_init().
This change is part of an ongoing effort to separate initialization from
allocation within the xhci driver. By doing so, it will enable future
patches to re-initialize xhci driver memory without the necessity of fully
recreating it.

Additionally, compliance mode recovery initialization has been adjusted to
only occur after successful memory allocation.

Signed-off-by: Niklas Neronin <niklas.neronin@linux.intel.com>
Signed-off-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Link: https://lore.kernel.org/r/20250515135621.335595-4-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 7ff6a47d3198c8347034ffe37db1d93c1ee034d5..a7955e02905cb5c1c0d3b0299fbdf8159701e690 100644 (file)
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -2414,22 +2414,6 @@ xhci_create_secondary_interrupter(struct usb_hcd *hcd, unsigned int segs,
 }
 EXPORT_SYMBOL_GPL(xhci_create_secondary_interrupter);
 
-static void xhci_hcd_page_size(struct xhci_hcd *xhci)
-{
-       u32 page_size;
-
-       page_size = readl(&xhci->op_regs->page_size) & XHCI_PAGE_SIZE_MASK;
-       if (!is_power_of_2(page_size)) {
-               xhci_warn(xhci, "Invalid page size register = 0x%x\n", page_size);
-               /* Fallback to 4K page size, since that's common */
-               page_size = 1;
-       }
-
-       xhci->page_size = page_size << 12;
-       xhci_dbg_trace(xhci, trace_xhci_dbg_init, "HCD page size set to %iK",
-                      xhci->page_size >> 10);
-}
-
 int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
 {
        struct xhci_interrupter *ir;
@@ -2438,15 +2422,6 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
        unsigned int    val, val2;
        u64             val_64;
        u32             temp;
-       int             i;
-
-       INIT_LIST_HEAD(&xhci->cmd_list);
-
-       /* init command timeout work */
-       INIT_DELAYED_WORK(&xhci->cmd_timer, xhci_handle_command_timeout);
-       init_completion(&xhci->cmd_ring_stop_completion);
-
-       xhci_hcd_page_size(xhci);
 
        /*
         * Program the Number of Device Slots Enabled field in the CONFIG
@@ -2567,9 +2542,6 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
 
        ir->isoc_bei_interval = AVOID_BEI_INTERVAL_MAX;
 
-       for (i = 0; i < MAX_HC_SLOTS; i++)
-               xhci->devs[i] = NULL;
-
        if (scratchpad_alloc(xhci, flags))
                goto fail;
        if (xhci_setup_port_arrays(xhci, flags))

diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index fd9d41fe32248076f1c7bbafbea799958c65c91c..b073e9d916651ea8e6903311b6804cafdb420a5b 100644 (file)
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -461,6 +461,21 @@ static int xhci_all_ports_seen_u0(struct xhci_hcd *xhci)
        return (xhci->port_status_u0 == ((1 << xhci->usb3_rhub.num_ports) - 1));
 }
 
+static void xhci_hcd_page_size(struct xhci_hcd *xhci)
+{
+       u32 page_size;
+
+       page_size = readl(&xhci->op_regs->page_size) & XHCI_PAGE_SIZE_MASK;
+       if (!is_power_of_2(page_size)) {
+               xhci_warn(xhci, "Invalid page size register = 0x%x\n", page_size);
+               /* Fallback to 4K page size, since that's common */
+               page_size = 1;
+       }
+
+       xhci->page_size = page_size << 12;
+       xhci_dbg_trace(xhci, trace_xhci_dbg_init, "HCD page size set to %iK",
+                      xhci->page_size >> 10);
+}
 
 /*
  * Initialize memory for HCD and xHC (one-time init).
@@ -474,11 +489,18 @@ static int xhci_init(struct usb_hcd *hcd)
        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
        int retval;
 
-       xhci_dbg_trace(xhci, trace_xhci_dbg_init, "xhci_init");
+       xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Starting %s", __func__);
        spin_lock_init(&xhci->lock);
 
+       INIT_LIST_HEAD(&xhci->cmd_list);
+       INIT_DELAYED_WORK(&xhci->cmd_timer, xhci_handle_command_timeout);
+       init_completion(&xhci->cmd_ring_stop_completion);
+       xhci_hcd_page_size(xhci);
+       memset(xhci->devs, 0, MAX_HC_SLOTS * sizeof(*xhci->devs));
+
        retval = xhci_mem_init(xhci, GFP_KERNEL);
-       xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Finished xhci_init");
+       if (retval)
+               return retval;
 
        /* Initializing Compliance Mode Recovery Data If Needed */
        if (xhci_compliance_mode_recovery_timer_quirk_check()) {
@@ -486,7 +508,8 @@ static int xhci_init(struct usb_hcd *hcd)
                compliance_mode_recovery_timer_init(xhci);
        }
 
-       return retval;
+       xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Finished %s", __func__);
+       return 0;
 }
 
 /*-------------------------------------------------------------------------*/