From patchwork Thu Nov 10 08:00:04 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Albert Wang X-Patchwork-Id: 18002 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:6687:0:0:0:0:0 with SMTP id l7csp10467wru; Thu, 10 Nov 2022 00:07:02 -0800 (PST) X-Google-Smtp-Source: AMsMyM6FRvR2xBpogySxify7+92+QxKR3PXXidEPd4F26+DyYAt5OaFbelEVsobpIqx2AGFQpoWa X-Received: by 2002:a17:906:40d2:b0:79e:8360:8c3d with SMTP id a18-20020a17090640d200b0079e83608c3dmr2529088ejk.146.1668067621872; Thu, 10 Nov 2022 00:07:01 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1668067621; cv=none; d=google.com; s=arc-20160816; b=RAZdaY4lGekb11LHwutNeW9qxZYrItMoFRPhvdZf2Ti8boPGiYcmuTdrUVliGS5foZ i6yhSlzxyuPS+QgGu55gRxXQkFBbP8eAUxe/LM6OtHkZ37BtGhCssXDjPTEwlAvXZoKS uinZ441du5m7vbYHi7eLCSJckYxEcNqhuvqGHyuxY5YgWUcqPkcmZ2LYvRAdxgGSY3MB lUdhyKOl/Ik2tloukTOglilr5yOKKEkg4StBzcOU8npflSyCYleHftzlsaT4KyqwQPc1 qTKStPoxbiC85ScdJ6tpxhVZitQb3uv5rD0ytvb2x73VgB6rd84LLVkzrLaKXINtjs0a xbxg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:references:mime-version :message-id:in-reply-to:date:dkim-signature; bh=4Mlhvy7LVfX8RsDMkCEDUilCHxpF1dj6dt7DixRlTa4=; b=bMX65tE3tQIjBy5FayInBXSTd8P/FDpfUAq2JeDKaNVWYtoBw2ksuBGpOgKwaqFLiq j3mBe+CtdzA+GB44xYRVIJihV9NN/ttRQIIh8pWnIwdhEl569oT5mgn9UdW9wth8VEo2 nUq9Go5RrGvvamvUR3EbyFl+fucEu8neX2EsUcCu8Shy+yw6HGmNsxx8ASipnIkuWinz PzSqrkdesKsmODBnBH5q2SjUq914OhoS001N+LXf7IITFBCXw5fzbb26McfDfJMENB/1 UR9qYopqpClDNwQZk7xYKfAg408owLxMvjINYZwGT3kCuqPqbLf/sG8EVV9T/H/znosC quHA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=jPPXDBUR; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id nb30-20020a1709071c9e00b007a7d37e4684si19753750ejc.803.2022.11.10.00.06.37; Thu, 10 Nov 2022 00:07:01 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=jPPXDBUR; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232893AbiKJIBB (ORCPT + 99 others); Thu, 10 Nov 2022 03:01:01 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34084 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232766AbiKJIA4 (ORCPT ); Thu, 10 Nov 2022 03:00:56 -0500 Received: from mail-yw1-x114a.google.com (mail-yw1-x114a.google.com [IPv6:2607:f8b0:4864:20::114a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C5BF51CB01 for ; Thu, 10 Nov 2022 00:00:54 -0800 (PST) Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-368994f4bc0so9771617b3.14 for ; Thu, 10 Nov 2022 00:00:54 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=4Mlhvy7LVfX8RsDMkCEDUilCHxpF1dj6dt7DixRlTa4=; b=jPPXDBURrtwvQYF7HqZe1kuBWz2SIPYRRDSQtlyqhuoTABxMiNSDGB8emDo6vChHDR iu1TzAaWrfurbfhGuDFJxE2Mt4v5pI/awSB5deSi4zuv0iuxy4CLnCy3y+LVJP3n6BcC SeHjDNU3f7s70gvNz0+FKq63K5z5meTnMe/hpWOBcZuktLxsAcSbrf1+zqBZ7B08rO+z 2DUjXshNnjwqv4uYI0ZtrBHa24nZugnB/LIT4EaxY7a/DYzXDrQU6rlXj9zWD/FTJS6x U0qqEmuuHHz7Mwrs7e3UtbjhDI0fGqAx4efkz9Gd2kzNSRLMqIH2tCU1b8XqgSyoWWzT Z/0Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=4Mlhvy7LVfX8RsDMkCEDUilCHxpF1dj6dt7DixRlTa4=; b=A6QEBxZxuDPNGjGGIHOCQlGnRSFV2g+Rz2TzkmVXeLMDR9lJrWRXkYLOdZX8KryQ+a jG0VQLu9XXQZm3YvPG6Ug7dJWIYBe0QeLgNrO5T0Pkuh11wKyoHZizz3wY8mASO1lgN5 VdYi3zAjJ5LAIBQA2luJ6lQRBz13cd6cteCXWuc/NhCgpGq1e+m3oOPMBkRMdztIzr5x 0Xwfka4GqbM84lX47NeHExJwYwKRJ9cKIXkLLGKVHi6su8kKLb6UZXzySVAMP+7qOf94 7CwtVZgldWJmCt8w4ALrx+n21m8vZScyvOkVcNtdtQGAYpBGi5oHjuA/kAgFdQZ1XtiB olSA== X-Gm-Message-State: ACrzQf0S/7bXRcYwuUAuybeHeJkacNXTsQnq8UmKTndNdcPwKw0X3McG DyMSK+a/ZKqtuW0j6i9k+kMrQZ7qMspt5ffLODg= X-Received: from albertccwang.ntc.corp.google.com ([2401:fa00:fc:202:2c6f:5c28:5579:9e27]) (user=albertccwang job=sendgmr) by 2002:a0d:f985:0:b0:370:72ad:bc17 with SMTP id j127-20020a0df985000000b0037072adbc17mr48281356ywf.233.1668067253938; Thu, 10 Nov 2022 00:00:53 -0800 (PST) Date: Thu, 10 Nov 2022 16:00:04 +0800 In-Reply-To: <20221110080006.3563429-1-albertccwang@google.com> Message-Id: <20221110080006.3563429-2-albertccwang@google.com> Mime-Version: 1.0 References: <20221110080006.3563429-1-albertccwang@google.com> X-Mailer: git-send-email 2.38.1.431.g37b22c650d-goog Subject: [PATCH v2 1/3] usb: host: add xhci hooks for USB offload From: Albert Wang To: mathias.nyman@intel.com, gregkh@linuxfoundation.org Cc: badhri@google.com, howardyen@google.com, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org X-Spam-Status: No, score=-8.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,HK_RANDOM_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1749095674156572043?= X-GMAIL-MSGID: =?utf-8?q?1749095674156572043?= From: Howard Yen This change is to provide USB offload function which allows to offload some xHCI operations on co-processor. This is especially designed for USB audio usecase. The co-processor is able to manipulate some USB structures in his own memory, like SRAM. There are several offload_ops introduced by this patch: struct xhci_offload_ops - function callbacks for offlad specific operations { @offload_init: - called for vendor init process during xhci-plat-hcd probe. @offload_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 @usb_offload_skip_urb: - called to check if need to skip urb enqueue } The xhci hooks with prefix "xhci_vendor_" on the ops in xhci_offload_ops. For example, offload_init ops will be invoked by xhci_vendor_offload_init() hook,is_usb_offload_enabled ops will be invoked by xhci_vendor_is_usb_offload_enabled(), and so on. Signed-off-by: Howard Yen --- Changes in v2: - Remove irq work, device context synchronization - Remove export symbols - Use 'offload_ops' instead of 'vendor_ops' drivers/usb/host/xhci-mem.c | 97 +++++++++++++++++++++++++++++++----- drivers/usb/host/xhci-plat.c | 23 +++++++++ drivers/usb/host/xhci-plat.h | 1 + drivers/usb/host/xhci.c | 21 ++++++++ drivers/usb/host/xhci.h | 31 ++++++++++++ 5 files changed, 160 insertions(+), 13 deletions(-) diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c index 81ca2bc1f0be..ab0ef19d4fa3 100644 --- a/drivers/usb/host/xhci-mem.c +++ b/drivers/usb/host/xhci-mem.c @@ -361,6 +361,38 @@ static int xhci_alloc_segments_for_ring(struct xhci_hcd *xhci, return 0; } +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_offload_ops *ops = xhci_offload_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; +} + +static void xhci_vendor_free_transfer_ring(struct xhci_hcd *xhci, + struct xhci_virt_device *virt_dev, unsigned int ep_index) +{ + struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci); + + if (ops && ops->free_transfer_ring) + ops->free_transfer_ring(xhci, virt_dev, ep_index); +} + +static bool xhci_vendor_is_offload_enabled(struct xhci_hcd *xhci, + struct xhci_virt_device *virt_dev, unsigned int ep_index) +{ + struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci); + + if (ops && ops->is_offload_enabled) + return ops->is_offload_enabled(xhci, virt_dev, ep_index); + + return false; +} + /* * Create a new ring with zero or more segments. * @@ -412,7 +444,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_offload_enabled(xhci, virt_dev, ep_index)) + xhci_vendor_free_transfer_ring(xhci, virt_dev, ep_index); + else + xhci_ring_free(xhci, virt_dev->eps[ep_index].ring); + virt_dev->eps[ep_index].ring = NULL; } @@ -885,7 +921,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); @@ -1487,8 +1523,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_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; @@ -1832,6 +1876,23 @@ void xhci_free_erst(struct xhci_hcd *xhci, struct xhci_erst *erst) erst->entries = NULL; } +static void xhci_vendor_alloc_dcbaa( + struct xhci_hcd *xhci, gfp_t flags) +{ + struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci); + + if (ops && ops->alloc_dcbaa) + return ops->alloc_dcbaa(xhci, flags); +} + +static void xhci_vendor_free_dcbaa(struct xhci_hcd *xhci) +{ + struct xhci_offload_ops *ops = xhci_offload_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; @@ -1883,9 +1944,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_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); @@ -2422,15 +2487,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_offload_enabled(xhci, NULL, 0)) { + 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 5fb55bf19493..2f04acb42fa6 100644 --- a/drivers/usb/host/xhci-plat.c +++ b/drivers/usb/host/xhci-plat.c @@ -173,6 +173,23 @@ static const struct of_device_id usb_xhci_of_match[] = { MODULE_DEVICE_TABLE(of, usb_xhci_of_match); #endif +static int xhci_vendor_init(struct xhci_hcd *xhci) +{ + struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci); + + if (ops && ops->offload_init) + return ops->offload_init(xhci); + return 0; +} + +static void xhci_vendor_cleanup(struct xhci_hcd *xhci) +{ + struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci); + + if (ops && ops->offload_cleanup) + ops->offload_cleanup(xhci); +} + static int xhci_plat_probe(struct platform_device *pdev) { const struct xhci_plat_priv *priv_match; @@ -317,6 +334,10 @@ static int xhci_plat_probe(struct platform_device *pdev) goto disable_clk; } + ret = xhci_vendor_init(xhci); + if (ret) + goto disable_usb_phy; + hcd->tpl_support = of_usb_host_tpl_support(sysdev->of_node); if (priv && (priv->quirks & XHCI_SKIP_PHY_INIT)) @@ -410,6 +431,8 @@ static int xhci_plat_remove(struct platform_device *dev) if (shared_hcd) usb_put_hcd(shared_hcd); + xhci_vendor_cleanup(xhci); + 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..5aa0d38fa01a 100644 --- a/drivers/usb/host/xhci-plat.h +++ b/drivers/usb/host/xhci-plat.h @@ -13,6 +13,7 @@ struct xhci_plat_priv { const char *firmware_name; unsigned long long quirks; + struct xhci_offload_ops *offload_ops; void (*plat_start)(struct usb_hcd *); int (*init_quirk)(struct usb_hcd *); int (*suspend_quirk)(struct usb_hcd *); diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c index 79d7931c048a..75d39fe0d44d 100644 --- a/drivers/usb/host/xhci.c +++ b/drivers/usb/host/xhci.c @@ -22,6 +22,7 @@ #include "xhci-trace.h" #include "xhci-debugfs.h" #include "xhci-dbgcap.h" +#include "xhci-plat.h" #define DRIVER_AUTHOR "Sarah Sharp" #define DRIVER_DESC "'eXtensible' Host Controller (xHC) Driver" @@ -1669,6 +1670,11 @@ static int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flag return -ENODEV; } + if (xhci_vendor_usb_offload_skip_urb(xhci, urb)) { + xhci_dbg(xhci, "skip urb for usb offload\n"); + return -EOPNOTSUPP; + } + if (usb_endpoint_xfer_isoc(&urb->ep->desc)) num_tds = urb->number_of_packets; else if (usb_endpoint_is_bulk_out(&urb->ep->desc) && @@ -4441,6 +4447,21 @@ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci, return ret; } +struct xhci_offload_ops *xhci_offload_get_ops(struct xhci_hcd *xhci) +{ + return xhci_to_priv(xhci)->offload_ops; +} +EXPORT_SYMBOL_GPL(xhci_offload_get_ops); + +bool xhci_vendor_usb_offload_skip_urb(struct xhci_hcd *xhci, struct urb *urb) +{ + struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci); + + if (ops && ops->usb_offload_skip_urb) + return ops->usb_offload_skip_urb(xhci, urb); + return false; +} + #ifdef CONFIG_PM /* BESL to HIRD Encoding array for USB2 LPM */ diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h index cc084d9505cd..d67bea2c180d 100644 --- a/drivers/usb/host/xhci.h +++ b/drivers/usb/host/xhci.h @@ -2229,6 +2229,37 @@ static inline struct xhci_ring *xhci_urb_to_transfer_ring(struct xhci_hcd *xhci, urb->stream_id); } +/** + * struct xhci_offload_ops - function callbacks for offload specific operations + * @offload_init: called for offload init process + * @offload_cleanup: called for offload cleanup process + * @is_usb_offload_enabled: called to check if xhci offload enabled + * @alloc_dcbaa: called when allocating specific dcbaa for offload + * @free_dcbaa: called to free specific dcbaa for offload + * @alloc_transfer_ring: called when remote transfer ring allocation is required + * @free_transfer_ring: called to free specific transfer ring for offload + * @usb_offload_skip_urb: called to check if need to skip urb + */ +struct xhci_offload_ops { + int (*offload_init)(struct xhci_hcd *xhci); + void (*offload_cleanup)(struct xhci_hcd *xhci); + bool (*is_offload_enabled)(struct xhci_hcd *xhci, + struct xhci_virt_device *vdev, + unsigned int ep_index); + void (*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_virt_device *virt_dev, unsigned int ep_index); + bool (*usb_offload_skip_urb)(struct xhci_hcd *xhci, struct urb *urb); +}; + +struct xhci_offload_ops *xhci_offload_get_ops(struct xhci_hcd *xhci); +bool xhci_vendor_usb_offload_skip_urb(struct xhci_hcd *xhci, struct urb *urb); + /* * TODO: As per spec Isochronous IDT transmissions are supported. We bypass * them anyways as we where unable to find a device that matches the From patchwork Thu Nov 10 08:00:05 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Albert Wang X-Patchwork-Id: 18001 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:6687:0:0:0:0:0 with SMTP id l7csp9732wru; Thu, 10 Nov 2022 00:05:32 -0800 (PST) X-Google-Smtp-Source: AMsMyM52lb8042t4J5JtBvKpa39edMVB07iYe43e7nrj9eRpGf3FNTzt0EKRNWIoreXyQ6gKhDLQ X-Received: by 2002:a17:906:db0a:b0:781:f24:a782 with SMTP id xj10-20020a170906db0a00b007810f24a782mr59253804ejb.399.1668067531908; Thu, 10 Nov 2022 00:05:31 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1668067531; cv=none; d=google.com; s=arc-20160816; b=zfMOJaecJR4yS9D8H5xhuT3CAFp3JR8RdDdzRAhVKUULjWKEdmxF+LP3FzStpVyrje Fbth4wt5o+e1XNCs8d8uAGCvArKA+MP4F54IKBxmTc8QS7wmvD+frlAtDn1ehCy/JCnj 5M0xIIF6igfu3vC+VZt+nAB27aaSYFJIMct/mmrlcb5rmK7WDPabVIcZ1/CovIp+MHBR EPf+0Schk98c8xXDAE2DYNQHgN6JEClC6XX69RINrlqGh5iquAj6cV+mbRnT4EEfXNqk HVXQYUOMObQYChSr/HZCe3Jp3pd9aVG4oRGWNJJRcTCxbpWByrb/KkSSs5+UyeqaFhnS 9+OA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:references:mime-version :message-id:in-reply-to:date:dkim-signature; bh=O8vK2CTFtLD5YGZvxAtHHt4MBxX8fsqvLDieKgi2UpY=; b=yhzgUJcKSZH+F2DrrAizX3xf4ca94xXv0j/J+TnIg+UlTV3cz/unRxcYx6EisyuV9e bD/vF8/gD/66uMq2AZZjcBjb8IIFYVLBffnf1hy8W/v13I2y6gZf05/fzIUOU/SYjsVk w+LelZgGMyZNev7FHnhYvRTRePNzbCwGFEd3wvuJEIqolTYodrXBE8TJb1ReUd6B9ZGw G0GI8oojRoXHtBswz79TvyEuImC2sYZHriNOqKwmFqsVHx77+KTKzWgXMdZx95k8oGoo hrkg8Pp/cpLlSPX7Vha9PLKoM/BKhi9i+ebLSgoLayAIxyatEi+j7solR8LBjM0S7Vx2 gOhg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b="HaF/H/3M"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id ds14-20020a170907724e00b007adc5c4626bsi20054130ejc.50.2022.11.10.00.05.05; Thu, 10 Nov 2022 00:05:31 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b="HaF/H/3M"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232913AbiKJIBE (ORCPT + 99 others); Thu, 10 Nov 2022 03:01:04 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34104 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232871AbiKJIBA (ORCPT ); Thu, 10 Nov 2022 03:01:00 -0500 Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EE9CC1CB01 for ; Thu, 10 Nov 2022 00:00:59 -0800 (PST) Received: by mail-yb1-xb49.google.com with SMTP id i65-20020a25d144000000b006cfec5975d5so1146842ybg.15 for ; Thu, 10 Nov 2022 00:00:59 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=O8vK2CTFtLD5YGZvxAtHHt4MBxX8fsqvLDieKgi2UpY=; b=HaF/H/3MkcFULhHBzOSB9PUz3Skp+KtwKWMvJkFA25o4ce0byRTJRnB1Pftp0lH62r 9A4GwUXfbkSXOn6ueebI8CtEhwk9spUrrxU5UJ1ZuRVgvd0CfdUhd8cP7vG3f3WCtYdq vxDnon+DaljAFnAfHzb+ISco8ApoRXACL/qfXvS/MotOfYrhhiKyn7SC5vTRUrBY+04w bspiXPgGN5190d3+v6SP6zrc2UOdEwict7cVQO3vD4uBtphtjXoK6Ymm/YDPujpJtKY/ zk7k2etjtzYtKvlzfR38vTKUgyy3FaBlKyXuqu+8EtEdO71LM7cm0wwz8INlx9w0cxjl oGxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=O8vK2CTFtLD5YGZvxAtHHt4MBxX8fsqvLDieKgi2UpY=; b=egnmNZsNySsqG1EYJbSN/AjYYbUDYbzw6HutgDmiFUowmel4v2AZacZb5TvOE/JUjx 6kquPoipRdgIqGXjUB7tNR9J5YdFkbZv/5e35jdclUVOAfsOu7qBQwd222G9ICXLV7e/ Qx/f5K0ng3/dAT0t8Ge2doMSqb/RdznI/vVg/QTzYFpW0KYFfy+AfyNXnwJ7cL7mjIxX 94X0YoXRmcvjhYFWN+o7LBHbB6H3HDdYtRC7CBVFemuMdXN/s/ASC8BNRlv1DdmZvgKN uGUdVpPmIICAYpTCaMuOo+2FDJQXk6A5GulRcylXlT3g9KX4ANc8BPrEIFasVVHcubxn 9Q4g== X-Gm-Message-State: ACrzQf0N1uw394v4hPtM5x5m2fWMDOAWz4ky+JrWjub/Q/foaoWAwiT8 aq43RLW/WqDxHa/E3ajpludAe0Pgyv3t43kE9uY= X-Received: from albertccwang.ntc.corp.google.com ([2401:fa00:fc:202:2c6f:5c28:5579:9e27]) (user=albertccwang job=sendgmr) by 2002:a81:9c51:0:b0:373:448b:6aea with SMTP id n17-20020a819c51000000b00373448b6aeamr44918198ywa.265.1668067259237; Thu, 10 Nov 2022 00:00:59 -0800 (PST) Date: Thu, 10 Nov 2022 16:00:05 +0800 In-Reply-To: <20221110080006.3563429-1-albertccwang@google.com> Message-Id: <20221110080006.3563429-3-albertccwang@google.com> Mime-Version: 1.0 References: <20221110080006.3563429-1-albertccwang@google.com> X-Mailer: git-send-email 2.38.1.431.g37b22c650d-goog Subject: [PATCH v2 2/3] usb: xhci-plat: add xhci_plat_priv_overwrite From: Albert Wang To: mathias.nyman@intel.com, gregkh@linuxfoundation.org Cc: badhri@google.com, howardyen@google.com, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org X-Spam-Status: No, score=-8.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,HK_RANDOM_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1749095580558105098?= X-GMAIL-MSGID: =?utf-8?q?1749095580558105098?= From: Howard Yen Add an overwrite to platform specific callback for setting up the xhci_offload_ops, allow vendor to store the xhci_offload_ops and overwrite them when xhci_plat_probe invoked. Signed-off-by: Howard Yen --- Changes in v2: - Use 'offload_ops' instead of 'vendor_ops' drivers/usb/host/xhci-plat.c | 20 ++++++++++++++++++++ drivers/usb/host/xhci-plat.h | 7 +++++++ 2 files changed, 27 insertions(+) diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c index 2f04acb42fa6..11ff89f722b7 100644 --- a/drivers/usb/host/xhci-plat.c +++ b/drivers/usb/host/xhci-plat.c @@ -173,9 +173,26 @@ 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_offload_ops(struct xhci_offload_ops *offload_ops) +{ + if (offload_ops == NULL) + return -EINVAL; + + xhci_plat_vendor_overwrite.offload_ops = offload_ops; + + return 0; +} +EXPORT_SYMBOL_GPL(xhci_plat_register_offload_ops); + static int xhci_vendor_init(struct xhci_hcd *xhci) { struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci); + struct xhci_plat_priv *priv = xhci_to_priv(xhci); + + if (xhci_plat_vendor_overwrite.offload_ops) + ops = priv->offload_ops = xhci_plat_vendor_overwrite.offload_ops; if (ops && ops->offload_init) return ops->offload_init(xhci); @@ -185,9 +202,12 @@ static int xhci_vendor_init(struct xhci_hcd *xhci) static void xhci_vendor_cleanup(struct xhci_hcd *xhci) { struct xhci_offload_ops *ops = xhci_offload_get_ops(xhci); + struct xhci_plat_priv *priv = xhci_to_priv(xhci); if (ops && ops->offload_cleanup) ops->offload_cleanup(xhci); + + priv->offload_ops = NULL; } static int xhci_plat_probe(struct platform_device *pdev) diff --git a/drivers/usb/host/xhci-plat.h b/drivers/usb/host/xhci-plat.h index 5aa0d38fa01a..0656d6daa194 100644 --- a/drivers/usb/host/xhci-plat.h +++ b/drivers/usb/host/xhci-plat.h @@ -22,4 +22,11 @@ struct xhci_plat_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_offload_ops *offload_ops; +}; + +int xhci_plat_register_offload_ops(struct xhci_offload_ops *offload_ops); + #endif /* _XHCI_PLAT_H */ From patchwork Thu Nov 10 08:00:06 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Albert Wang X-Patchwork-Id: 18004 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:6687:0:0:0:0:0 with SMTP id l7csp11274wru; Thu, 10 Nov 2022 00:08:46 -0800 (PST) X-Google-Smtp-Source: AMsMyM6qQnCbQdkWQVAwSI/GhXW9t1XCzR/XzzO/3p1mp0WJlcZ9Ze4RHk/rUFAJmgQRLRQ+4pug X-Received: by 2002:a17:906:a17:b0:78d:9d06:c7cc with SMTP id w23-20020a1709060a1700b0078d9d06c7ccmr2431614ejf.154.1668067725820; Thu, 10 Nov 2022 00:08:45 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1668067725; cv=none; d=google.com; s=arc-20160816; b=M+TVQNPuTM4Fn63fRMKmOx5w1ZpuWXEIPCCLbPn8Duj6XYV8dzZdrNLpUWEpqD7VRj aqXBSdhcAzt86sFBT5jUOzJj1Gpf28ROT3C+idfoP21euF4Sfnx+V/Bm83Tj8YWXZRne TqMgftKQi5CXr1uNNLvhz25hsjdTOPeD+iCkXS6d9YZ9JYlybZ/nm83gJT9niqAhMcqf JHuV2gmbXMPcMbvAZXAudLUPVzkU5PnAAgNcchtN5npt7u6wRe5EfBn858dOxDxLRfgz nezHwMH1owVDKqluNfeIVx0srKT8g2cFe7EbXzV6sKEWfWIpMdMujWOzUYVY2Hr6JozC CT5A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:references:mime-version :message-id:in-reply-to:date:dkim-signature; bh=5kJlT7ntgoYuCv4/yBaIZRIBzCyj+KBksQs6ck5uymo=; b=n5WDr1HT8/ED5KAdUVXL5e+N64glDR+7hjSmRlUwMEaHE7LEM7wDkMrHFTl3k5nZFa /LWQ3JjfNGI8/jDu/hZE6zBSUON5Hdjh/JxJwKB95L4qIrMDisJlDn7vBcu6ydkkEFyR WSywxB1BB/qPEtXIDL172nV3qGn793NhWBxwnH/bVtssp1YTZx8BeVWPH+LEI5LdSR7x q7141pGFWlv8RzcLKvgZGF9UmmrNCYYNOrURCEBLg1B/S0ZyvzD9NhHp4YGQ/78ZqEwG WXyKcLVyDwP6ldHNjEXKYW0l3oYqE6RYD5zvxmwUr78SxPKcHV2UkWa2UnImB9pXFqB1 85mQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=fDaFqsnC; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id hq42-20020a1709073f2a00b007ae17fd2f19si18231298ejc.734.2022.11.10.00.08.03; Thu, 10 Nov 2022 00:08:45 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20210112 header.b=fDaFqsnC; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232766AbiKJIBN (ORCPT + 99 others); Thu, 10 Nov 2022 03:01:13 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34184 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232920AbiKJIBG (ORCPT ); Thu, 10 Nov 2022 03:01:06 -0500 Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5CD251C41F for ; Thu, 10 Nov 2022 00:01:05 -0800 (PST) Received: by mail-yb1-xb49.google.com with SMTP id f126-20020a255184000000b006cb2aebd124so1153775ybb.11 for ; Thu, 10 Nov 2022 00:01:05 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=5kJlT7ntgoYuCv4/yBaIZRIBzCyj+KBksQs6ck5uymo=; b=fDaFqsnCmWfOp2sCyDZ2LXluglt+9BGNMH4fv3LPb752IiaQvNyMynq5/u3trO/Smi tfXaDJ2X6KIcnFJ2Nu2wcLSWATosEnrNDsJM5GX8w+tzy2GF//YXWHuG6ADTj3O+e69h /LqgVmJX3+Gix6KAlje0eQ2G6CZM9GYxpqTWzpduHnEmaCKcVcBH0Ne0bSd79d2y7xn1 yLhJxBn2FdrKj/jDI9l2z1W0pQibOQf936dhCJ9hxtVdTe8XJcHa40jJPp2HiCpuUiiF jUZTY1uh8yLyx65sSHOjvCw0Oo936YiuN2Hmm8cBN+QMZ2CgXiUIF/VxGlYmihlUgsyD SBGA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:references:mime-version:message-id:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=5kJlT7ntgoYuCv4/yBaIZRIBzCyj+KBksQs6ck5uymo=; b=DmEg9yOykQnJlUmkCERef5jAPKD6We11kLjXgVH8pkYIExHLE2aDjV1dZb23hF4n9G 1OoJHoFWy+fAv3JV/9NU7oK6y4vIy51YKo98MUntXUHw86ltPczrcoy8tjZtlLK7Z0KT 9L8bCx34hg4kUGbzDqfUMrzasAjRl7LwYLH/K0KYK1HvLQzLNlFHAf77cX07k1gkS/Vw E2EgL6OkblpaG1pJtub4fsNz8Juqyry9dGX7ABtPke81FLvDlIafvc5eUGVRljfVs/1D REDO7XMexQ/stDN4sf8cYbGPUp5lp2uT7iuGbR8SooppQou603OAY85b+C2Wa6SU1HYE N3mg== X-Gm-Message-State: ACrzQf2rFk34VPgVvnB/MUqBrd3wTwsUiyQ4w2AG72LfXR5dx9oa6ra+ zfW/NfTVApsgXJIM7Ih345hi4Cc+YgXB1YTDJbM= X-Received: from albertccwang.ntc.corp.google.com ([2401:fa00:fc:202:2c6f:5c28:5579:9e27]) (user=albertccwang job=sendgmr) by 2002:a05:690c:601:b0:36b:b6f3:f0f4 with SMTP id bq1-20020a05690c060100b0036bb6f3f0f4mr1194837ywb.116.1668067264475; Thu, 10 Nov 2022 00:01:04 -0800 (PST) Date: Thu, 10 Nov 2022 16:00:06 +0800 In-Reply-To: <20221110080006.3563429-1-albertccwang@google.com> Message-Id: <20221110080006.3563429-4-albertccwang@google.com> Mime-Version: 1.0 References: <20221110080006.3563429-1-albertccwang@google.com> X-Mailer: git-send-email 2.38.1.431.g37b22c650d-goog Subject: [PATCH v2 3/3] usb: host: add the xhci offload hooks implementations From: Albert Wang To: mathias.nyman@intel.com, gregkh@linuxfoundation.org Cc: badhri@google.com, howardyen@google.com, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, Albert Wang X-Spam-Status: No, score=-8.6 required=5.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,HK_RANDOM_FROM, RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,USER_IN_DEF_DKIM_WL autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1749095783305126260?= X-GMAIL-MSGID: =?utf-8?q?1749095783305126260?= Add the offload hooks implementations which are used in the xHCI driver for vendor offload function, and some functions will call to co-processor driver for further offload operations. Signed-off-by: Albert Wang Signed-off-by: Howard Yen --- Changes in v2: - New in v2 drivers/usb/host/xhci-offload-impl.c | 492 +++++++++++++++++++++++++++ 1 file changed, 492 insertions(+) create mode 100644 drivers/usb/host/xhci-offload-impl.c diff --git a/drivers/usb/host/xhci-offload-impl.c b/drivers/usb/host/xhci-offload-impl.c new file mode 100644 index 000000000000..90e546d63fbe --- /dev/null +++ b/drivers/usb/host/xhci-offload-impl.c @@ -0,0 +1,492 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2020 Google Corp. + * + * Author: + * Howard.Yen + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "xhci.h" +#include "xhci-plat.h" + +enum usb_offload_op_mode { + USB_OFFLOAD_STOP, + USB_OFFLOAD_DRAM +}; + +enum usb_state { + USB_DISCONNECTED, + USB_CONNECTED +}; + +enum usb_offload_msg { + SET_DCBAA_PTR, + SETUP_DONE, + SET_ISOC_TR_INFO, + SYNC_CONN_STAT, + SET_OFFLOAD_STATE +}; + +struct conn_stat_args { + u16 bus_id; + u16 dev_num; + u16 slot_id; + u32 conn_stat; +}; + +struct get_isoc_tr_info_args { + u16 ep_id; + u16 dir; + u32 type; + u32 num_segs; + u32 seg_ptr; + u32 max_packet; + u32 deq_ptr; + u32 enq_ptr; + u32 cycle_state; + u32 num_trbs_free; +}; + +struct xhci_offload_data { + struct xhci_hcd *xhci; + + bool usb_accessory_enabled; + bool usb_audio_offload; + bool dt_direct_usb_access; + bool offload_state; + + enum usb_offload_op_mode op_mode; +}; + +static struct xhci_offload_data *offload_data; +struct xhci_offload_data *xhci_get_offload_data(void) +{ + return offload_data; +} + +/* + * Determine if an USB device is a compatible devices: + * True: Devices are audio class and they contain ISOC endpoint + * False: Devices are not audio class or they're audio class but no ISOC endpoint or + * they have at least one interface is video class + */ +static bool is_compatible_with_usb_audio_offload(struct usb_device *udev) +{ + struct usb_endpoint_descriptor *epd; + struct usb_host_config *config; + struct usb_host_interface *alt; + struct usb_interface_cache *intfc; + int i, j, k; + bool is_audio = false; + + config = udev->config; + for (i = 0; i < config->desc.bNumInterfaces; i++) { + intfc = config->intf_cache[i]; + for (j = 0; j < intfc->num_altsetting; j++) { + alt = &intfc->altsetting[j]; + + if (alt->desc.bInterfaceClass == USB_CLASS_VIDEO) { + is_audio = false; + goto out; + } + + if (alt->desc.bInterfaceClass == USB_CLASS_AUDIO) { + for (k = 0; k < alt->desc.bNumEndpoints; k++) { + epd = &alt->endpoint[k].desc; + if (usb_endpoint_xfer_isoc(epd)) { + is_audio = true; + break; + } + } + } + } + } + +out: + return is_audio; +} + +/* + * check the usb device including the video class: + * True: Devices contain video class + * False: Device doesn't contain video class + */ +static bool is_usb_video_device(struct usb_device *udev) +{ + struct usb_host_config *config; + struct usb_host_interface *alt; + struct usb_interface_cache *intfc; + int i, j; + bool is_video = false; + + if (!udev || !udev->config) + return is_video; + + config = udev->config; + + for (i = 0; i < config->desc.bNumInterfaces; i++) { + intfc = config->intf_cache[i]; + for (j = 0; j < intfc->num_altsetting; j++) { + alt = &intfc->altsetting[j]; + + if (alt->desc.bInterfaceClass == USB_CLASS_VIDEO) { + is_video = true; + goto out; + } + } + } + +out: + return is_video; +} + +/* + * This is the driver call to co-processor for offload operations. + */ +int offload_driver_call(enum usb_offload_msg msg, void *ptr) +{ + enum usb_offload_msg offload_msg; + void *argptr; + + offload_msg = msg; + argptr = ptr; + + return 0; +} + +static int xhci_sync_conn_stat(unsigned int bus_id, unsigned int dev_num, unsigned int slot_id, + unsigned int conn_stat) +{ + struct conn_stat_args conn_args; + + conn_args.bus_id = bus_id; + conn_args.dev_num = dev_num; + conn_args.slot_id = slot_id; + conn_args.conn_stat = conn_stat; + + return offload_driver_call(SYNC_CONN_STAT, &conn_args); +} + +static int usb_host_mode_state_notify(enum usb_state usb_state) +{ + return xhci_sync_conn_stat(0, 0, 0, usb_state); +} + +static int xhci_udev_notify(struct notifier_block *self, unsigned long action, + void *dev) +{ + struct usb_device *udev = dev; + struct xhci_offload_data *offload_data = xhci_get_offload_data(); + + switch (action) { + case USB_DEVICE_ADD: + if (is_compatible_with_usb_audio_offload(udev)) { + dev_dbg(&udev->dev, "Compatible with usb audio offload\n"); + if (offload_data->op_mode == USB_OFFLOAD_DRAM) { + xhci_sync_conn_stat(udev->bus->busnum, udev->devnum, udev->slot_id, + USB_CONNECTED); + } + } + offload_data->usb_accessory_enabled = false; + break; + case USB_DEVICE_REMOVE: + if (is_compatible_with_usb_audio_offload(udev) && + (offload_data->op_mode == USB_OFFLOAD_DRAM)) { + xhci_sync_conn_stat(udev->bus->busnum, udev->devnum, udev->slot_id, + USB_DISCONNECTED); + } + offload_data->usb_accessory_enabled = false; + break; + } + + return NOTIFY_OK; +} + +static struct notifier_block xhci_udev_nb = { + .notifier_call = xhci_udev_notify, +}; + +static int usb_audio_offload_init(struct xhci_hcd *xhci) +{ + struct device *dev = xhci_to_hcd(xhci)->self.sysdev; + struct xhci_offload_data *offload_data = xhci_get_offload_data(); + int ret; + u32 out_val; + + offload_data = kzalloc(sizeof(struct xhci_offload_data), GFP_KERNEL); + if (!offload_data) + return -ENOMEM; + + if (!of_property_read_u32(dev->of_node, "offload", &out_val)) + offload_data->usb_audio_offload = (out_val == 1) ? true : false; + + ret = of_reserved_mem_device_init(dev); + if (ret) { + dev_err(dev, "Could not get reserved memory\n"); + kfree(offload_data); + return ret; + } + + offload_data->dt_direct_usb_access = + of_property_read_bool(dev->of_node, "direct-usb-access") ? true : false; + if (!offload_data->dt_direct_usb_access) + dev_warn(dev, "Direct USB access is not supported\n"); + + offload_data->offload_state = true; + + usb_register_notify(&xhci_udev_nb); + offload_data->op_mode = USB_OFFLOAD_DRAM; + offload_data->xhci = xhci; + + return 0; +} + +static void usb_audio_offload_cleanup(struct xhci_hcd *xhci) +{ + struct xhci_offload_data *offload_data = xhci_get_offload_data(); + + offload_data->usb_audio_offload = false; + offload_data->op_mode = USB_OFFLOAD_STOP; + offload_data->xhci = NULL; + + usb_unregister_notify(&xhci_udev_nb); + + /* Notification for xhci driver removing */ + usb_host_mode_state_notify(USB_DISCONNECTED); + + kfree(offload_data); + offload_data = NULL; +} + +static bool is_offload_enabled(struct xhci_hcd *xhci, + struct xhci_virt_device *vdev, unsigned int ep_index) +{ + struct usb_device *udev; + struct xhci_offload_data *offload_data = xhci_get_offload_data(); + bool global_enabled = offload_data->op_mode != USB_OFFLOAD_STOP; + struct xhci_ring *ep_ring; + + if (vdev == NULL || vdev->eps[ep_index].ring == NULL) + return global_enabled; + + udev = vdev->udev; + + if (global_enabled) { + ep_ring = vdev->eps[ep_index].ring; + if (offload_data->op_mode == USB_OFFLOAD_DRAM) { + if (is_usb_video_device(udev)) + return false; + else if (ep_ring->type == TYPE_ISOC) + return offload_data->offload_state; + } + } + + return false; +} + +static bool is_usb_bulk_transfer_enabled(struct xhci_hcd *xhci, struct urb *urb) +{ + struct xhci_offload_data *offload_data = xhci_get_offload_data(); + struct usb_endpoint_descriptor *desc = &urb->ep->desc; + int ep_type = usb_endpoint_type(desc); + struct usb_ctrlrequest *cmd; + bool skip_bulk = false; + + cmd = (struct usb_ctrlrequest *) urb->setup_packet; + + if (ep_type == USB_ENDPOINT_XFER_CONTROL) { + if (!usb_endpoint_dir_in(desc) && cmd->bRequest == 0x35) + offload_data->usb_accessory_enabled = true; + else + offload_data->usb_accessory_enabled = false; + } + + if (ep_type == USB_ENDPOINT_XFER_BULK && !usb_endpoint_dir_in(desc)) + skip_bulk = offload_data->usb_accessory_enabled; + + return skip_bulk; +} + +static int xhci_set_dcbaa_ptr(u64 dcbaa_ptr) +{ + return offload_driver_call(SET_DCBAA_PTR, &dcbaa_ptr); +} + +static int xhci_setup_done(void) +{ + return offload_driver_call(SETUP_DONE, NULL); +} + +static void alloc_dcbaa(struct xhci_hcd *xhci, gfp_t flags) +{ + dma_addr_t dma; + struct device *dev = xhci_to_hcd(xhci)->self.sysdev; + struct xhci_offload_data *offload_data = xhci_get_offload_data(); + + if (offload_data->op_mode == USB_OFFLOAD_DRAM) { + xhci->dcbaa = dma_alloc_coherent(dev, sizeof(*xhci->dcbaa), + &dma, flags); + if (!xhci->dcbaa) + return; + + xhci->dcbaa->dma = dma; + if (xhci_set_dcbaa_ptr(xhci->dcbaa->dma) != 0) { + xhci_err(xhci, "Set DCBAA pointer failed\n"); + xhci->dcbaa = NULL; + return; + } + xhci_setup_done(); + + xhci_dbg(xhci, "Set dcbaa_ptr=%llx to AoC\n", xhci->dcbaa->dma); + } else { + xhci->dcbaa = dma_alloc_coherent(dev, sizeof(*xhci->dcbaa), + &dma, flags); + if (!xhci->dcbaa) + return; + + xhci->dcbaa->dma = dma; + } +} + +static void free_dcbaa(struct xhci_hcd *xhci) +{ + struct device *dev = xhci_to_hcd(xhci)->self.sysdev; + + if (!xhci->dcbaa) + return; + + dma_free_coherent(dev, sizeof(*xhci->dcbaa), + xhci->dcbaa, xhci->dcbaa->dma); + + xhci->dcbaa = NULL; +} + +static int xhci_set_isoc_tr_info(u16 ep_id, u16 dir, struct xhci_ring *ep_ring) +{ + struct get_isoc_tr_info_args tr_info; + + tr_info.ep_id = ep_id; + tr_info.dir = dir; + tr_info.num_segs = ep_ring->num_segs; + tr_info.max_packet = ep_ring->bounce_buf_len; + tr_info.type = ep_ring->type; + tr_info.seg_ptr = ep_ring->first_seg->dma; + tr_info.cycle_state = ep_ring->cycle_state; + tr_info.num_trbs_free = ep_ring->num_trbs_free; + + return offload_driver_call(SET_ISOC_TR_INFO, &tr_info); +} + +static 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) +{ + struct xhci_ring *ep_ring; + u16 dir; + + ep_ring = xhci_ring_alloc(xhci, 1, 1, ring_type, max_packet, mem_flags); + dir = endpoint_type == ISOC_IN_EP ? 0 : 1; + + xhci_set_isoc_tr_info(0, dir, ep_ring); + + return ep_ring; +} + +static void free_transfer_ring(struct xhci_hcd *xhci, struct xhci_virt_device *virt_dev, + unsigned int ep_index) +{ + struct xhci_ring *ring, *new_ring; + struct xhci_ep_ctx *ep_ctx; + struct xhci_input_control_ctx *ctrl_ctx; + u32 ep_type; + u32 ep_is_added, ep_is_dropped; + + ring = virt_dev->eps[ep_index].ring; + new_ring = virt_dev->eps[ep_index].new_ring; + ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->out_ctx, ep_index); + ep_type = CTX_TO_EP_TYPE(le32_to_cpu(ep_ctx->ep_info2)); + + ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx); + if (!ctrl_ctx) { + xhci_warn(xhci, "%s: Could not get input context, bad type.\n", __func__); + return; + } + ep_is_added = EP_IS_ADDED(ctrl_ctx, ep_index); + ep_is_dropped = EP_IS_DROPPED(ctrl_ctx, ep_index); + + xhci_dbg(xhci, "%s: ep %u is added(0x%x), is dropped(0x%x)\n", __func__, ep_index, + ep_is_added, ep_is_dropped); + + if (ring) { + xhci_dbg(xhci, "%s: ep_index=%u, ep_type=%u, ring type=%u, new_ring=%pK\n", + __func__, ep_index, ep_type, ring->type, new_ring); + + xhci_ring_free(xhci, virt_dev->eps[ep_index].ring); + + virt_dev->eps[ep_index].ring = NULL; + + if (ep_is_added == 0 && ep_is_dropped == 0) + return; + } + + if (new_ring) { + xhci_dbg(xhci, "%s: ep_index=%u, ep_type=%u, new_ring type=%u\n", __func__, + ep_index, ep_type, new_ring->type); + + xhci_ring_free(xhci, virt_dev->eps[ep_index].new_ring); + + virt_dev->eps[ep_index].new_ring = NULL; + + return; + } +} + +static bool offload_skip_urb(struct xhci_hcd *xhci, struct urb *urb) +{ + struct xhci_virt_device *vdev = xhci->devs[urb->dev->slot_id]; + struct usb_endpoint_descriptor *desc = &urb->ep->desc; + int ep_type = usb_endpoint_type(desc); + unsigned int ep_index; + + if (ep_type == USB_ENDPOINT_XFER_CONTROL) + ep_index = (unsigned int)(usb_endpoint_num(desc)*2); + else + ep_index = (unsigned int)(usb_endpoint_num(desc)*2) + + (usb_endpoint_dir_in(desc) ? 1 : 0) - 1; + + xhci_dbg(xhci, "%s: ep_index=%u, ep_type=%d\n", __func__, ep_index, ep_type); + + if (is_offload_enabled(xhci, vdev, ep_index)) + return true; + + if (is_usb_bulk_transfer_enabled(xhci, urb)) + return true; + + return false; +} + +static struct xhci_offload_ops offload_ops = { + .offload_init = usb_audio_offload_init, + .offload_cleanup = usb_audio_offload_cleanup, + .is_offload_enabled = is_offload_enabled, + .alloc_dcbaa = alloc_dcbaa, + .free_dcbaa = free_dcbaa, + .alloc_transfer_ring = alloc_transfer_ring, + .free_transfer_ring = free_transfer_ring, + .usb_offload_skip_urb = offload_skip_urb, +}; + +int xhci_offload_helper_init(void) +{ + return xhci_plat_register_offload_ops(&offload_ops); +}