usb: xhci: Add timeout argument in address_device USB HCD callback

- The HCD address_device callback now accepts a user-defined timeout value
  in milliseconds, providing better control over command execution times.
- The default timeout value for the address_device command has been set
  to 5000 ms, aligning with the USB 3.2 specification. However, this
  timeout can be adjusted as needed.
- The xhci_setup_device function has been updated to accept the timeout
  value, allowing it to specify the maximum wait time for the command
  operation to complete.
- The hub driver has also been updated to accommodate the newly added
  timeout parameter during the SET_ADDRESS request.

Signed-off-by: Hardik Gajjar <hgajjar@de.adit-jv.com>
Reviewed-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Link: https://lore.kernel.org/r/20231027152029.104363-1-hgajjar@de.adit-jv.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index b4584a0cd484562633488d1552f60281d527bd6a..0490582643678be5f2ae50f0c67936ed6a14a7eb 100644 (file)
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -4662,7 +4662,7 @@ static int hub_set_address(struct usb_device *udev, int devnum)
        if (udev->state != USB_STATE_DEFAULT)
                return -EINVAL;
        if (hcd->driver->address_device)
-               retval = hcd->driver->address_device(hcd, udev);
+               retval = hcd->driver->address_device(hcd, udev, USB_CTRL_SET_TIMEOUT);
        else
                retval = usb_control_msg(udev, usb_sndaddr0pipe(),
                                USB_REQ_SET_ADDRESS, 0, devnum, 0,

diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 62116586848b84a160b11fcba5a4f2ba035b10c9..6faa854152ef1a31adee7bf334aea9a5924c97a1 100644 (file)
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1739,6 +1739,8 @@ struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
        }
 
        command->status = 0;
+       /* set default timeout to 5000 ms */
+       command->timeout_ms = XHCI_CMD_DEFAULT_TIMEOUT;
        INIT_LIST_HEAD(&command->cmd_list);
        return command;
 }

diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index f3b5e6345858c4485c321c674559c8a60f3221eb..2c1d614b3b0fbefef4d1a5b57d0db2395f1d8ba7 100644 (file)
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -366,9 +366,10 @@ void xhci_ring_cmd_db(struct xhci_hcd *xhci)
        readl(&xhci->dba->doorbell[0]);
 }
 
-static bool xhci_mod_cmd_timer(struct xhci_hcd *xhci, unsigned long delay)
+static bool xhci_mod_cmd_timer(struct xhci_hcd *xhci)
 {
-       return mod_delayed_work(system_wq, &xhci->cmd_timer, delay);
+       return mod_delayed_work(system_wq, &xhci->cmd_timer,
+                       msecs_to_jiffies(xhci->current_cmd->timeout_ms));
 }
 
 static struct xhci_command *xhci_next_queued_cmd(struct xhci_hcd *xhci)
@@ -412,7 +413,7 @@ static void xhci_handle_stopped_cmd_ring(struct xhci_hcd *xhci,
        if ((xhci->cmd_ring->dequeue != xhci->cmd_ring->enqueue) &&
            !(xhci->xhc_state & XHCI_STATE_DYING)) {
                xhci->current_cmd = cur_cmd;
-               xhci_mod_cmd_timer(xhci, XHCI_CMD_DEFAULT_TIMEOUT);
+               xhci_mod_cmd_timer(xhci);
                xhci_ring_cmd_db(xhci);
        }
 }
@@ -1787,7 +1788,7 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
        if (!list_is_singular(&xhci->cmd_list)) {
                xhci->current_cmd = list_first_entry(&cmd->cmd_list,
                                                struct xhci_command, cmd_list);
-               xhci_mod_cmd_timer(xhci, XHCI_CMD_DEFAULT_TIMEOUT);
+               xhci_mod_cmd_timer(xhci);
        } else if (xhci->current_cmd == cmd) {
                xhci->current_cmd = NULL;
        }
@@ -4287,7 +4288,7 @@ static int queue_command(struct xhci_hcd *xhci, struct xhci_command *cmd,
        /* if there are no other commands queued we start the timeout timer */
        if (list_empty(&xhci->cmd_list)) {
                xhci->current_cmd = cmd;
-               xhci_mod_cmd_timer(xhci, XHCI_CMD_DEFAULT_TIMEOUT);
+               xhci_mod_cmd_timer(xhci);
        }
 
        list_add_tail(&cmd->cmd_list, &xhci->cmd_list);

diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 884b0898d9c9577c4554ac9559a3a064caefd936..cb885ddc203267640df18065d134e11e12bfd56d 100644 (file)
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -4029,12 +4029,18 @@ disable_slot:
        return 0;
 }
 
-/*
- * Issue an Address Device command and optionally send a corresponding
- * SetAddress request to the device.
+/**
+ * xhci_setup_device - issues an Address Device command to assign a unique
+ *                     USB bus address.
+ * @hcd: USB host controller data structure.
+ * @udev: USB dev structure representing the connected device.
+ * @setup: Enum specifying setup mode: address only or with context.
+ * @timeout_ms: Max wait time (ms) for the command operation to complete.
+ *
+ * Return: 0 if successful; otherwise, negative error code.
  */
 static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
-                            enum xhci_setup_dev setup)
+                            enum xhci_setup_dev setup, unsigned int timeout_ms)
 {
        const char *act = setup == SETUP_CONTEXT_ONLY ? "context" : "address";
        unsigned long flags;
@@ -4091,6 +4097,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
        }
 
        command->in_ctx = virt_dev->in_ctx;
+       command->timeout_ms = timeout_ms;
 
        slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
        ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx);
@@ -4217,14 +4224,16 @@ out:
        return ret;
 }
 
-static int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
+static int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev,
+                              unsigned int timeout_ms)
 {
-       return xhci_setup_device(hcd, udev, SETUP_CONTEXT_ADDRESS);
+       return xhci_setup_device(hcd, udev, SETUP_CONTEXT_ADDRESS, timeout_ms);
 }
 
 static int xhci_enable_device(struct usb_hcd *hcd, struct usb_device *udev)
 {
-       return xhci_setup_device(hcd, udev, SETUP_CONTEXT_ONLY);
+       return xhci_setup_device(hcd, udev, SETUP_CONTEXT_ONLY,
+                                XHCI_CMD_DEFAULT_TIMEOUT);
 }
 
 /*

diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 3ea5c092bba7176fbbbf01aa597107178ececb31..62b610f007544d128d3954661ca028ee3323779e 100644 (file)
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -791,6 +791,8 @@ struct xhci_command {
        struct completion               *completion;
        union xhci_trb                  *command_trb;
        struct list_head                cmd_list;
+       /* xHCI command response timeout in milliseconds */
+       unsigned int                    timeout_ms;
 };
 
 /* drop context bitmasks */
@@ -1550,8 +1552,11 @@ struct xhci_td {
        unsigned int            num_trbs;
 };
 
-/* xHCI command default timeout value */
-#define XHCI_CMD_DEFAULT_TIMEOUT       (5 * HZ)
+/*
+ * xHCI command default timeout value in milliseconds.
+ * USB 3.2 spec, section 9.2.6.1
+ */
+#define XHCI_CMD_DEFAULT_TIMEOUT       5000
 
 /* command descriptor */
 struct xhci_cd {

diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 00724b4f6e122bf700da6c0c81c250c7c6bc19f7..cd77fc6095a15b5f8d313179436fc8b33efbc769 100644 (file)
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -372,8 +372,9 @@ struct hc_driver {
                 * or bandwidth constraints.
                 */
        void    (*reset_bandwidth)(struct usb_hcd *, struct usb_device *);
-               /* Returns the hardware-chosen device address */
-       int     (*address_device)(struct usb_hcd *, struct usb_device *udev);
+               /* Set the hardware-chosen device address */
+       int     (*address_device)(struct usb_hcd *, struct usb_device *udev,
+                                 unsigned int timeout_ms);
                /* prepares the hardware to send commands to the device */
        int     (*enable_device)(struct usb_hcd *, struct usb_device *udev);
                /* Notifies the HCD after a hub descriptor is fetched.