Re: [PATCH v2] usb: core: hub: Add quirks for reducing device address timeout

[Mathias Nyman <mathias.nyman@intel.com>]

On 9.10.2023 19.14, Hardik Gajjar wrote:
> Currently, the timeout for the set address command is fixed at
> 5 seconds in the xhci driver. This means the host waits up to 5
> seconds to receive a response for the set_address command from
> the device.
> 
> In the automotive context, most smartphone enumerations, including
> screen projection, should ideally complete within 3 seconds.
> Achieving this is impossible in scenarios where the set_address is
> not successful and waits for a timeout.
> 
> The shortened address device timeout quirks provide the flexibility
> to align with a 3-second time limit in the event of errors.
> By swiftly triggering a failure response and swiftly initiating
> retry procedures, these quirks ensure efficient and rapid recovery,
> particularly in automotive contexts where rapid smartphone enumeration
> and screen projection are vital.
> 
> The quirk will set the timeout to 500 ms from 5 seconds.
> 
> To use the quirk, please write "vendor_id:product_id:p" to
> /sys/bus/usb/drivers/hub/module/parameter/quirks
> 
> For example,
> echo "0x2c48:0x0132:p" > /sys/bus/usb/drivers/hub/module/parameter/quirks"
> 
> Signed-off-by: Hardik Gajjar <hgajjar@de.adit-jv.com>
> ---
> changes since version 1:
> 	- implement quirk instead of new API in xhci driver
> ---
>   drivers/usb/core/hub.c       | 15 +++++++++++++--
>   drivers/usb/core/quirks.c    |  3 +++
>   drivers/usb/host/xhci-mem.c  |  1 +
>   drivers/usb/host/xhci-ring.c |  3 ++-
>   drivers/usb/host/xhci.c      |  9 +++++----
>   drivers/usb/host/xhci.h      |  1 +
>   include/linux/usb/hcd.h      |  3 ++-
>   include/linux/usb/quirks.h   |  3 +++
>   8 files changed, 30 insertions(+), 8 deletions(-)
> 
> diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
> index 3c54b218301c..975449b03426 100644
> --- a/drivers/usb/core/hub.c
> +++ b/drivers/usb/core/hub.c
> @@ -54,6 +54,9 @@
>   #define USB_TP_TRANSMISSION_DELAY_MAX	65535	/* ns */
>   #define USB_PING_RESPONSE_TIME		400	/* ns */
>   
> +#define USB_DEFAULT_ADDR_DEVICE_TIMEOUT		(HZ * 5) /* 5000ms */
> +#define USB_SHORT_ADDR_DEVICE_TIMEOUT		125  /* ~500ms */

maybe use milliseconds directly
define USB_DEFAULT_ADDR_DEVICE_TIMEOUT		5000	/* ms */
...

> +
>   /* Protect struct usb_device->state and ->children members
>    * Note: Both are also protected by ->dev.sem, except that ->state can
>    * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
> @@ -4626,8 +4629,16 @@ EXPORT_SYMBOL_GPL(usb_ep0_reinit);
>   static int hub_set_address(struct usb_device *udev, int devnum)
>   {
>   	int retval;
> +	int timeout = USB_DEFAULT_ADDR_DEVICE_TIMEOUT;
>   	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
>   
> +	struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
> +
> +	if (hub->hdev->quirks & USB_QUIRK_SHORT_DEVICE_ADDR_TIMEOUT)
> +		timeout = USB_SHORT_ADDR_DEVICE_TIMEOUT;
> +
> +	dev_dbg(&udev->dev, "address_device timeout %d\n", timeout);
> +
>   	/*
>   	 * The host controller will choose the device address,
>   	 * instead of the core having chosen it earlier
> @@ -4639,11 +4650,11 @@ 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, timeout);
>   	else
>   		retval = usb_control_msg(udev, usb_sndaddr0pipe(),
>   				USB_REQ_SET_ADDRESS, 0, devnum, 0,
> -				NULL, 0, USB_CTRL_SET_TIMEOUT);
> +				NULL, 0, jiffies_to_msecs(timeout));
>   	if (retval == 0) {
>   		update_devnum(udev, devnum);
>   		/* Device now using proper address. */
> diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
> index 15e9bd180a1d..01ed26bd41f0 100644
> --- a/drivers/usb/core/quirks.c
> +++ b/drivers/usb/core/quirks.c
> @@ -138,6 +138,9 @@ static int quirks_param_set(const char *value, const struct kernel_param *kp)
>   			case 'o':
>   				flags |= USB_QUIRK_HUB_SLOW_RESET;
>   				break;
> +			case 'p':
> +				flags |= USB_QUIRK_SHORT_DEVICE_ADDR_TIMEOUT;
> +				break;
>   			/* Ignore unrecognized flag characters */
>   			}
>   		}
> diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
> index 8714ab5bf04d..492433fdac77 100644
> --- a/drivers/usb/host/xhci-mem.c
> +++ b/drivers/usb/host/xhci-mem.c
> @@ -1729,6 +1729,7 @@ struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
>   	}
>   
>   	command->status = 0;
> +	command->timeout = 0;

This could be command->timeout = XHCI_CMD_DEFAULT_TIMEOUT_MS;
For address device commands we then  override it later in xhci_setup_device()

The default xhci command timeout could be changed to 5000ms instead of 5 * HZ,
so in xhci.h:

/* Default xhci command timeout in milliseconds */
XHCI_CMD_DEFAULT_TIMEOUT_MS	5000

>   	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 1dde53f6eb31..0bd19a1efdec 100644
> --- a/drivers/usb/host/xhci-ring.c
> +++ b/drivers/usb/host/xhci-ring.c
> @@ -4301,7 +4301,8 @@ 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, (cmd->timeout) ? cmd->timeout :
> +				XHCI_CMD_DEFAULT_TIMEOUT);

xhci_mod_cmd_timer(xhci, cmd->timeout);

We would then also need to convert ms to jiffies in xhci_mod_cmd_timer():

return mod_delayed_work(system_wq, &xhci->cmd_timer, msecs_to_jiffies(delay));


>   	}
>   
>   	list_add_tail(&cmd->cmd_list, &xhci->cmd_list);
> diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
> index e1b1b64a0723..1d088ceb2b74 100644
> --- a/drivers/usb/host/xhci.c
> +++ b/drivers/usb/host/xhci.c
> @@ -4002,7 +4002,7 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
>    * SetAddress request to the device.
>    */
>   static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
> -			     enum xhci_setup_dev setup)
> +			     enum xhci_setup_dev setup, int timeout)
  
Hmm, I know usb_control_msg() uses int for timeout, but unsigned int would seem more
appropriate.

Same for xhci_address_device() and xhci_enable_device()

>   {
>   	const char *act = setup == SETUP_CONTEXT_ONLY ? "context" : "address";
>   	unsigned long flags;
> @@ -4059,6 +4059,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
>   	}
>   
>   	command->in_ctx = virt_dev->in_ctx;
> +	command->timeout = timeout;
>   
>   	slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
>   	ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx);
> @@ -4185,14 +4186,14 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
>   	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, int timeout)
>   {
> -	return xhci_setup_device(hcd, udev, SETUP_CONTEXT_ADDRESS);
> +	return xhci_setup_device(hcd, udev, SETUP_CONTEXT_ADDRESS, timeout);
>   }
>   
>   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, 0);

return xhci_setup_device(hcd, udev, SETUP_CONTEXT_ONLY, XHCI_CMD_DEFAULT_TIMEOUT_MS);

>   }
>   
>   /*
> diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
> index 7e282b4522c0..ebdca8dd01c2 100644
> --- a/drivers/usb/host/xhci.h
> +++ b/drivers/usb/host/xhci.h
> @@ -818,6 +818,7 @@ struct xhci_command {
>   	struct completion		*completion;
>   	union xhci_trb			*command_trb;
>   	struct list_head		cmd_list;
> +	int				timeout;

unsigned int?

Thanks
Mathias