Re: [PATCH v4 2/5] usb: host: add xhci hooks for xhci-exynos

Greg Kroah-Hartman
2022-04-26T10:34:20Z

On Tue, Apr 26, 2022 at 06:18:45PM +0900, Daehwan Jung wrote:
> To enable supporting for USB offload, define "offload" in usb controller
> node of device tree. "offload" value can be used to determine which type
> of offload was been enabled in the SoC.
>
> For example:
>
> &usbdrd_dwc3 {
> ...
> /* support usb offloading, 0: disabled, 1: audio */
> offload = <1>;
> ...
> };
>
> There are several vendor_ops introduced by this patch:
>
> struct xhci_vendor_ops - function callbacks for vendor specific operations
> {
> @vendor_init:
> - called for vendor init process during xhci-plat-hcd
> probe.
> @vendor_cleanup:
> - called for vendor cleanup process during xhci-plat-hcd
> remove.
> @is_usb_offload_enabled:
> - called to check if usb offload enabled.
> @alloc_dcbaa:
> - called when allocating vendor specific dcbaa during
> memory initializtion.
> @free_dcbaa:
> - called to free vendor specific dcbaa when cleanup the
> memory.
> @alloc_transfer_ring:
> - called when vendor specific transfer ring allocation is required
> @free_transfer_ring:
> - called to free vendor specific transfer ring
> @sync_dev_ctx:
> - called when synchronization for device context is required
> }
>
> The xhci hooks with prefix "xhci_vendor_" on the ops in xhci_vendor_ops.
> For example, vendor_init ops will be invoked by xhci_vendor_init() hook,
> is_usb_offload_enabled ops will be invoked by
> xhci_vendor_is_usb_offload_enabled(), and so on.
>
> Signed-off-by: Daehwan Jung <dh10.jung@samsung.com>
> Signed-off-by: J. Avila <elavila@google.com>
> Signed-off-by: Puma Hsu <pumahsu@google.com>
> Signed-off-by: Howard Yen <howardyen@google.com>
> ---
> drivers/usb/host/xhci-hub.c | 5 ++
> drivers/usb/host/xhci-mem.c | 131 +++++++++++++++++++++++++++++++----
> drivers/usb/host/xhci-plat.c | 44 +++++++++++-
> drivers/usb/host/xhci-plat.h | 8 +++
> drivers/usb/host/xhci.c | 80 ++++++++++++++++++++-
> drivers/usb/host/xhci.h | 46 ++++++++++++
> 6 files changed, 296 insertions(+), 18 deletions(-)

Why do you need to "override" anything? Why can't these just be added
to the current xhci_plat_priv structure and used that way like the
current xhci platform interface works?

>
> diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
> index 841617952ac7..e07c9c132061 100644
> --- a/drivers/usb/host/xhci-hub.c
> +++ b/drivers/usb/host/xhci-hub.c
> @@ -535,8 +535,13 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
> cmd->status == COMP_COMMAND_RING_STOPPED) {
> xhci_warn(xhci, "Timeout while waiting for stop endpoint command\n");
> ret = -ETIME;
> + goto cmd_cleanup;
> }
>
> + ret = xhci_vendor_sync_dev_ctx(xhci, slot_id);
> + if (ret)
> + xhci_warn(xhci, "Sync device context failed, ret=%d\n", ret);

Shouldn't the function have spit out an error if there was a problem?

> +
> cmd_cleanup:
> xhci_free_command(xhci, cmd);
> return ret;
> diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
> index 82b9f90c0f27..5ee0ffb676d3 100644
> --- a/drivers/usb/host/xhci-mem.c
> +++ b/drivers/usb/host/xhci-mem.c
> @@ -365,6 +365,54 @@ static int xhci_alloc_segments_for_ring(struct xhci_hcd *xhci,
> return 0;
> }
>
> +static void xhci_vendor_free_container_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx)
> +{
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> + if (ops && ops->free_container_ctx)
> + ops->free_container_ctx(xhci, ctx);
> +}
> +
> +static void xhci_vendor_alloc_container_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx,
> + int type, gfp_t flags)
> +{
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> + if (ops && ops->alloc_container_ctx)
> + ops->alloc_container_ctx(xhci, ctx, type, flags);
> +}
> +
> +static struct xhci_ring *xhci_vendor_alloc_transfer_ring(struct xhci_hcd *xhci,
> + u32 endpoint_type, enum xhci_ring_type ring_type,
> + unsigned int max_packet, gfp_t mem_flags)
> +{
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> + if (ops && ops->alloc_transfer_ring)
> + return ops->alloc_transfer_ring(xhci, endpoint_type, ring_type,
> + max_packet, mem_flags);
> + return 0;
> +}
> +
> +void xhci_vendor_free_transfer_ring(struct xhci_hcd *xhci,
> + struct xhci_ring *ring, unsigned int ep_index)
> +{
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> + if (ops && ops->free_transfer_ring)
> + ops->free_transfer_ring(xhci, ring, ep_index);
> +}
> +
> +bool xhci_vendor_is_usb_offload_enabled(struct xhci_hcd *xhci,
> + struct xhci_virt_device *virt_dev, unsigned int ep_index)
> +{
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> + if (ops && ops->is_usb_offload_enabled)
> + return ops->is_usb_offload_enabled(xhci, virt_dev, ep_index);
> + return false;
> +}
> +
> /*
> * Create a new ring with zero or more segments.
> *
> @@ -417,7 +465,11 @@ void xhci_free_endpoint_ring(struct xhci_hcd *xhci,
> struct xhci_virt_device *virt_dev,
> unsigned int ep_index)
> {
> - xhci_ring_free(xhci, virt_dev->eps[ep_index].ring);
> + if (xhci_vendor_is_usb_offload_enabled(xhci, virt_dev, ep_index))
> + xhci_vendor_free_transfer_ring(xhci, virt_dev->eps[ep_index].ring, ep_index);
> + else
> + xhci_ring_free(xhci, virt_dev->eps[ep_index].ring);
> +
> virt_dev->eps[ep_index].ring = NULL;
> }
>
> @@ -475,6 +527,7 @@ struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci,
> {
> struct xhci_container_ctx *ctx;
> struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
>
> if ((type != XHCI_CTX_TYPE_DEVICE) && (type != XHCI_CTX_TYPE_INPUT))
> return NULL;
> @@ -488,7 +541,12 @@ struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci,
> if (type == XHCI_CTX_TYPE_INPUT)
> ctx->size += CTX_SIZE(xhci->hcc_params);
>
> - ctx->bytes = dma_pool_zalloc(xhci->device_pool, flags, &ctx->dma);
> + if (xhci_vendor_is_usb_offload_enabled(xhci, NULL, 0) &&
> + (ops && ops->alloc_container_ctx))
> + xhci_vendor_alloc_container_ctx(xhci, ctx, type, flags);
> + else
> + ctx->bytes = dma_pool_zalloc(xhci->device_pool, flags, &ctx->dma);
> +
> if (!ctx->bytes) {
> kfree(ctx);
> return NULL;
> @@ -499,9 +557,16 @@ struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci,
> void xhci_free_container_ctx(struct xhci_hcd *xhci,
> struct xhci_container_ctx *ctx)
> {
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> if (!ctx)
> return;
> - dma_pool_free(xhci->device_pool, ctx->bytes, ctx->dma);
> + if (xhci_vendor_is_usb_offload_enabled(xhci, NULL, 0) &&
> + (ops && ops->free_container_ctx))
> + xhci_vendor_free_container_ctx(xhci, ctx);
> + else
> + dma_pool_free(xhci->device_pool, ctx->bytes, ctx->dma);
> +
> kfree(ctx);
> }
>
> @@ -894,7 +959,7 @@ void xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id)
>
> for (i = 0; i < 31; i++) {
> if (dev->eps[i].ring)
> - xhci_ring_free(xhci, dev->eps[i].ring);
> + xhci_free_endpoint_ring(xhci, dev, i);
> if (dev->eps[i].stream_info)
> xhci_free_stream_info(xhci,
> dev->eps[i].stream_info);
> @@ -1492,8 +1557,16 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
> mult = 0;
>
> /* Set up the endpoint ring */
> - virt_dev->eps[ep_index].new_ring =
> - xhci_ring_alloc(xhci, 2, 1, ring_type, max_packet, mem_flags);
> + if (xhci_vendor_is_usb_offload_enabled(xhci, virt_dev, ep_index) &&
> + usb_endpoint_xfer_isoc(&ep->desc)) {
> + virt_dev->eps[ep_index].new_ring =
> + xhci_vendor_alloc_transfer_ring(xhci, endpoint_type, ring_type,
> + max_packet, mem_flags);
> + } else {
> + virt_dev->eps[ep_index].new_ring =
> + xhci_ring_alloc(xhci, 2, 1, ring_type, max_packet, mem_flags);
> + }
> +
> if (!virt_dev->eps[ep_index].new_ring)
> return -ENOMEM;
>
> @@ -1837,6 +1910,24 @@ void xhci_free_erst(struct xhci_hcd *xhci, struct xhci_erst *erst)
> erst->entries = NULL;
> }
>
> +static struct xhci_device_context_array *xhci_vendor_alloc_dcbaa(
> + struct xhci_hcd *xhci, gfp_t flags)
> +{
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> + if (ops && ops->alloc_dcbaa)
> + return ops->alloc_dcbaa(xhci, flags);
> + return 0;
> +}
> +
> +static void xhci_vendor_free_dcbaa(struct xhci_hcd *xhci)
> +{
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> + if (ops && ops->free_dcbaa)
> + ops->free_dcbaa(xhci);
> +}
> +
> void xhci_mem_cleanup(struct xhci_hcd *xhci)
> {
> struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
> @@ -1888,9 +1979,13 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
> xhci_dbg_trace(xhci, trace_xhci_dbg_init,
> "Freed medium stream array pool");
>
> - if (xhci->dcbaa)
> - dma_free_coherent(dev, sizeof(*xhci->dcbaa),
> - xhci->dcbaa, xhci->dcbaa->dma);
> + if (xhci_vendor_is_usb_offload_enabled(xhci, NULL, 0)) {
> + xhci_vendor_free_dcbaa(xhci);
> + } else {
> + if (xhci->dcbaa)
> + dma_free_coherent(dev, sizeof(*xhci->dcbaa),
> + xhci->dcbaa, xhci->dcbaa->dma);
> + }
> xhci->dcbaa = NULL;
>
> scratchpad_free(xhci);
> @@ -2427,15 +2522,21 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
> * xHCI section 5.4.6 - Device Context array must be
> * "physically contiguous and 64-byte (cache line) aligned".
> */
> - xhci->dcbaa = dma_alloc_coherent(dev, sizeof(*xhci->dcbaa), &dma,
> - flags);
> - if (!xhci->dcbaa)
> - goto fail;
> - xhci->dcbaa->dma = dma;
> + if (xhci_vendor_is_usb_offload_enabled(xhci, NULL, 0)) {
> + xhci->dcbaa = xhci_vendor_alloc_dcbaa(xhci, flags);
> + if (!xhci->dcbaa)
> + goto fail;
> + } else {
> + xhci->dcbaa = dma_alloc_coherent(dev, sizeof(*xhci->dcbaa), &dma,
> + flags);
> + if (!xhci->dcbaa)
> + goto fail;
> + xhci->dcbaa->dma = dma;
> + }
> xhci_dbg_trace(xhci, trace_xhci_dbg_init,
> "// Device context base array address = 0x%llx (DMA), %p (virt)",
> (unsigned long long)xhci->dcbaa->dma, xhci->dcbaa);
> - xhci_write_64(xhci, dma, &xhci->op_regs->dcbaa_ptr);
> + xhci_write_64(xhci, xhci->dcbaa->dma, &xhci->op_regs->dcbaa_ptr);
>
> /*
> * Initialize the ring segment pool. The ring must be a contiguous
> diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
> index 649ffd861b44..a5881ff945a6 100644
> --- a/drivers/usb/host/xhci-plat.c
> +++ b/drivers/usb/host/xhci-plat.c
> @@ -173,6 +173,41 @@ static const struct of_device_id usb_xhci_of_match[] = {
> MODULE_DEVICE_TABLE(of, usb_xhci_of_match);
> #endif
>
> +static struct xhci_plat_priv_overwrite xhci_plat_vendor_overwrite;
> +
> +int xhci_plat_register_vendor_ops(struct xhci_vendor_ops *vendor_ops)
> +{
> + if (vendor_ops == NULL)
> + return -EINVAL;
> +
> + xhci_plat_vendor_overwrite.vendor_ops = vendor_ops;
> +
> + return 0;
> +}
> +EXPORT_SYMBOL_GPL(xhci_plat_register_vendor_ops);
> +
> +static int xhci_vendor_init(struct xhci_hcd *xhci, struct device *dev)
> +{
> + struct xhci_vendor_ops *ops = NULL;
> +
> + if (xhci_plat_vendor_overwrite.vendor_ops)
> + ops = xhci->vendor_ops = xhci_plat_vendor_overwrite.vendor_ops;
> +
> + if (ops && ops->vendor_init)
> + return ops->vendor_init(xhci, dev);
> + return 0;
> +}
> +
> +static void xhci_vendor_cleanup(struct xhci_hcd *xhci)
> +{
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> + if (ops && ops->vendor_cleanup)
> + ops->vendor_cleanup(xhci);
> +
> + xhci->vendor_ops = NULL;
> +}
> +
> static int xhci_plat_probe(struct platform_device *pdev)
> {
> const struct xhci_plat_priv *priv_match;
> @@ -185,7 +220,6 @@ static int xhci_plat_probe(struct platform_device *pdev)
> int irq;
> struct xhci_plat_priv *priv = NULL;
>
> -
> if (usb_disabled())
> return -ENODEV;
>
> @@ -321,6 +355,10 @@ static int xhci_plat_probe(struct platform_device *pdev)
> goto put_usb3_hcd;
> }
>
> + ret = xhci_vendor_init(xhci, &pdev->dev);
> + if (ret)
> + goto disable_usb_phy;
> +
> hcd->tpl_support = of_usb_host_tpl_support(sysdev->of_node);
> xhci->shared_hcd->tpl_support = hcd->tpl_support;
> if (priv && (priv->quirks & XHCI_SKIP_PHY_INIT))
> @@ -393,8 +431,10 @@ static int xhci_plat_remove(struct platform_device *dev)
> usb_phy_shutdown(hcd->usb_phy);
>
> usb_remove_hcd(hcd);
> - usb_put_hcd(shared_hcd);
>
> + xhci_vendor_cleanup(xhci);
> +
> + usb_put_hcd(shared_hcd);
> clk_disable_unprepare(clk);
> clk_disable_unprepare(reg_clk);
> usb_put_hcd(hcd);
> diff --git a/drivers/usb/host/xhci-plat.h b/drivers/usb/host/xhci-plat.h
> index 1fb149d1fbce..8c204f3234d8 100644
> --- a/drivers/usb/host/xhci-plat.h
> +++ b/drivers/usb/host/xhci-plat.h
> @@ -17,8 +17,16 @@ struct xhci_plat_priv {
> int (*init_quirk)(struct usb_hcd *);
> int (*suspend_quirk)(struct usb_hcd *);
> int (*resume_quirk)(struct usb_hcd *);
> + void *vendor_priv;
> };
>
> #define hcd_to_xhci_priv(h) ((struct xhci_plat_priv *)hcd_to_xhci(h)->priv)
> #define xhci_to_priv(x) ((struct xhci_plat_priv *)(x)->priv)
> +
> +struct xhci_plat_priv_overwrite {
> + struct xhci_vendor_ops *vendor_ops;
> +};
> +
> +int xhci_plat_register_vendor_ops(struct xhci_vendor_ops *vendor_ops);
> +
> #endif /* _XHCI_PLAT_H */
> diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
> index c06e8b21b724..5ccf1bbe8732 100644
> --- a/drivers/usb/host/xhci.c
> +++ b/drivers/usb/host/xhci.c
> @@ -2986,6 +2986,14 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
> xhci_finish_resource_reservation(xhci, ctrl_ctx);
> spin_unlock_irqrestore(&xhci->lock, flags);
> }
> + if (ret)
> + goto failed;
> +
> + ret = xhci_vendor_sync_dev_ctx(xhci, udev->slot_id);
> + if (ret)
> + xhci_warn(xhci, "sync device context failed, ret=%d", ret);
> +
> +failed:
> return ret;
> }
>
> @@ -3129,7 +3137,11 @@ void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
> for (i = 0; i < 31; i++) {
> if (virt_dev->eps[i].new_ring) {
> xhci_debugfs_remove_endpoint(xhci, virt_dev, i);
> - xhci_ring_free(xhci, virt_dev->eps[i].new_ring);
> + if (xhci_vendor_is_usb_offload_enabled(xhci, virt_dev, i))
> + xhci_vendor_free_transfer_ring(xhci, virt_dev->eps[i].new_ring, i);
> + else
> + xhci_ring_free(xhci, virt_dev->eps[i].new_ring);
> +
> virt_dev->eps[i].new_ring = NULL;
> }
> }
> @@ -3290,6 +3302,13 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd,
>
> wait_for_completion(stop_cmd->completion);
>
> + err = xhci_vendor_sync_dev_ctx(xhci, udev->slot_id);
> + if (err) {
> + xhci_warn(xhci, "%s: Failed to sync device context failed, err=%d",
> + __func__, err);
> + goto cleanup;
> + }
> +
> spin_lock_irqsave(&xhci->lock, flags);
>
> /* config ep command clears toggle if add and drop ep flags are set */
> @@ -3321,6 +3340,11 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd,
>
> wait_for_completion(cfg_cmd->completion);
>
> + err = xhci_vendor_sync_dev_ctx(xhci, udev->slot_id);
> + if (err)
> + xhci_warn(xhci, "%s: Failed to sync device context failed, err=%d",
> + __func__, err);
> +
> xhci_free_command(xhci, cfg_cmd);
> cleanup:
> xhci_free_command(xhci, stop_cmd);
> @@ -3866,6 +3890,13 @@ static int xhci_discover_or_reset_device(struct usb_hcd *hcd,
> /* Wait for the Reset Device command to finish */
> wait_for_completion(reset_device_cmd->completion);
>
> + ret = xhci_vendor_sync_dev_ctx(xhci, slot_id);
> + if (ret) {
> + xhci_warn(xhci, "%s: Failed to sync device context failed, err=%d",
> + __func__, ret);
> + goto command_cleanup;
> + }
> +
> /* The Reset Device command can't fail, according to the 0.95/0.96 spec,
> * unless we tried to reset a slot ID that wasn't enabled,
> * or the device wasn't in the addressed or configured state.
> @@ -4111,6 +4142,14 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
> xhci_warn(xhci, "Could not allocate xHCI USB device data structures\n");
> goto disable_slot;
> }
> +
> + ret = xhci_vendor_sync_dev_ctx(xhci, slot_id);
> + if (ret) {
> + xhci_warn(xhci, "%s: Failed to sync device context failed, err=%d",
> + __func__, ret);
> + goto disable_slot;
> + }
> +
> vdev = xhci->devs[slot_id];
> slot_ctx = xhci_get_slot_ctx(xhci, vdev->out_ctx);
> trace_xhci_alloc_dev(slot_ctx);
> @@ -4241,6 +4280,13 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
> /* ctrl tx can take up to 5 sec; XXX: need more time for xHC? */
> wait_for_completion(command->completion);
>
> + ret = xhci_vendor_sync_dev_ctx(xhci, udev->slot_id);
> + if (ret) {
> + xhci_warn(xhci, "%s: Failed to sync device context failed, err=%d",
> + __func__, ret);
> + goto out;
> + }
> +
> /* FIXME: From section 4.3.4: "Software shall be responsible for timing
> * the SetAddress() "recovery interval" required by USB and aborting the
> * command on a timeout.
> @@ -4393,6 +4439,14 @@ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci,
> return -ENOMEM;
> }
>
> + ret = xhci_vendor_sync_dev_ctx(xhci, udev->slot_id);
> + if (ret) {
> + spin_unlock_irqrestore(&xhci->lock, flags);
> + xhci_warn(xhci, "%s: Failed to sync device context failed, err=%d",
> + __func__, ret);
> + return ret;
> + }
> +
> xhci_slot_copy(xhci, command->in_ctx, virt_dev->out_ctx);
> spin_unlock_irqrestore(&xhci->lock, flags);
>
> @@ -4420,6 +4474,21 @@ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci,
> return ret;
> }
>
> +struct xhci_vendor_ops *xhci_vendor_get_ops(struct xhci_hcd *xhci)
> +{
> + return xhci->vendor_ops;
> +}
> +EXPORT_SYMBOL_GPL(xhci_vendor_get_ops);
> +
> +int xhci_vendor_sync_dev_ctx(struct xhci_hcd *xhci, unsigned int slot_id)
> +{
> + struct xhci_vendor_ops *ops = xhci_vendor_get_ops(xhci);
> +
> + if (ops && ops->sync_dev_ctx)
> + return ops->sync_dev_ctx(xhci, slot_id);
> + return 0;
> +}
> +
> #ifdef CONFIG_PM
>
> /* BESL to HIRD Encoding array for USB2 LPM */
> @@ -5144,6 +5213,15 @@ static int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
> return -ENOMEM;
> }
>
> + ret = xhci_vendor_sync_dev_ctx(xhci, hdev->slot_id);
> + if (ret) {
> + xhci_warn(xhci, "%s: Failed to sync device context failed, err=%d",
> + __func__, ret);
> + xhci_free_command(xhci, config_cmd);
> + spin_unlock_irqrestore(&xhci->lock, flags);
> + return ret;
> + }
> +
> xhci_slot_copy(xhci, config_cmd->in_ctx, vdev->out_ctx);
> ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
> slot_ctx = xhci_get_slot_ctx(xhci, config_cmd->in_ctx);
> diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
> index 473a33ce299e..3a414a2f41f0 100644
> --- a/drivers/usb/host/xhci.h
> +++ b/drivers/usb/host/xhci.h
> @@ -1929,6 +1929,9 @@ struct xhci_hcd {
> struct list_head regset_list;
>
> void *dbc;
> +
> + struct xhci_vendor_ops *vendor_ops;
> +
> /* platform-specific data -- must come last */
> unsigned long priv[] __aligned(sizeof(s64));
> };
> @@ -2207,6 +2210,49 @@ static inline struct xhci_ring *xhci_urb_to_transfer_ring(struct xhci_hcd *xhci,
> urb->stream_id);
> }
>
> +/**
> + * struct xhci_vendor_ops - function callbacks for vendor specific operations
> + * @vendor_init: called for vendor init process
> + * @vendor_cleanup: called for vendor cleanup process
> + * @is_usb_offload_enabled: called to check if usb offload enabled
> + * @alloc_dcbaa: called when allocating vendor specific dcbaa
> + * @free_dcbaa: called to free vendor specific dcbaa
> + * @alloc_transfer_ring: called when remote transfer ring allocation is required
> + * @free_transfer_ring: called to free vendor specific transfer ring
> + * @sync_dev_ctx: called when synchronization for device context is required
> + * @alloc_container_ctx: called when allocating vendor specific container context
> + * @free_container_ctx: called to free vendor specific container context
> + */
> +struct xhci_vendor_ops {
> + int (*vendor_init)(struct xhci_hcd *xhci, struct device *dev);
> + void (*vendor_cleanup)(struct xhci_hcd *xhci);
> + bool (*is_usb_offload_enabled)(struct xhci_hcd *xhci,
> + struct xhci_virt_device *vdev,
> + unsigned int ep_index);
> +
> + struct xhci_device_context_array *(*alloc_dcbaa)(struct xhci_hcd *xhci,
> + gfp_t flags);
> + void (*free_dcbaa)(struct xhci_hcd *xhci);
> +
> + struct xhci_ring *(*alloc_transfer_ring)(struct xhci_hcd *xhci,
> + u32 endpoint_type, enum xhci_ring_type ring_type,
> + unsigned int max_packet, gfp_t mem_flags);
> + void (*free_transfer_ring)(struct xhci_hcd *xhci,
> + struct xhci_ring *ring, unsigned int ep_index);
> + int (*sync_dev_ctx)(struct xhci_hcd *xhci, unsigned int slot_id);
> + void (*alloc_container_ctx)(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx,
> + int type, gfp_t flags);
> + void (*free_container_ctx)(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx);
> +};
> +
> +struct xhci_vendor_ops *xhci_vendor_get_ops(struct xhci_hcd *xhci);
> +
> +int xhci_vendor_sync_dev_ctx(struct xhci_hcd *xhci, unsigned int slot_id);
> +void xhci_vendor_free_transfer_ring(struct xhci_hcd *xhci,
> + struct xhci_ring *ring, unsigned int ep_index);
> +bool xhci_vendor_is_usb_offload_enabled(struct xhci_hcd *xhci,
> + struct xhci_virt_device *virt_dev, unsigned int ep_index);

Why the three options here? Why does ep_index matter?

And no documentiaon for these global function?

thanks,

greg k-h