From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [1/4] usb: xhci: add Immediate Data Transfer support From: Mathias Nyman Message-Id: <1556285012-28186-2-git-send-email-mathias.nyman@linux.intel.com> Date: Fri, 26 Apr 2019 16:23:29 +0300 To: gregkh@linuxfoundation.org Cc: linux-usb@vger.kernel.org, Nicolas Saenz Julienne , Mathias Nyman List-ID: RnJvbTogTmljb2xhcyBTYWVueiBKdWxpZW5uZSA8bnNhZW56anVsaWVubmVAc3VzZS5kZT4KCklt bWVkaWF0ZSBkYXRhIHRyYW5zZmVycyAoSURUKSBhbGxvdyB0aGUgSENEIHRvIGNvcHkgc21hbGwg Y2h1bmtzIG9mCmRhdGEgKHVwIHRvIDhieXRlcykgZGlyZWN0bHkgaW50byBpdHMgb3V0cHV0IHRy YW5zZmVyIFRSQnMuIFRoaXMgYXZvaWRzCnRoZSBzb21ld2hhdCBleHBlbnNpdmUgRE1BIG1hcHBp bmdzIHRoYXQgYXJlIHBlcmZvcm1lZCBieSBkZWZhdWx0IG9uCm1vc3QgVVJCcyBzdWJtaXNzaW9u cy4KCkluIHRoZSBjYXNlIGFuIFVSQiB3YXMgc3VpdGFibGUgZm9yIElEVC4gVGhlIGRhdGEgaXMg ZGlyZWN0bHkgY29waWVkCmludG8gdGhlICJEYXRhIEJ1ZmZlciBQb2ludGVyIiByZWdpb24gb2Yg dGhlIFRSQiBhbmQgdGhlIElEVCBmbGFnIGlzCnNldC4gSW5zdGVhZCBvZiB0cmlnZ2VyaW5nIG1l bW9yeSBhY2Nlc3NlcyB0aGUgSEMgd2lsbCB1c2UgdGhlIGRhdGEKZGlyZWN0bHkuCgpUaGUgaW1w bGVtZW50YXRpb24gY291bGQgY292ZXIgYWxsIGtpbmQgb2Ygb3V0cHV0IGVuZHBvaW50cy4gWWV0 Cklzb2Nocm9ub3VzIGVuZHBvaW50cyBhcmUgYnlwYXNzZWQgYXMgSSB3YXMgdW5hYmxlIHRvIGZp bmQgb25lIHRoYXQKbWF0Y2hlZCBJRFQncyBjb25zdHJhaW50cy4gQXMgd2UgdHJ5IHRvIGJ5cGFz cyB0aGUgZGVmYXVsdCBETUEgbWFwcGluZ3MKb24gVVJCIGJ1ZmZlcnMgd2UnZCBuZWVkIHRvIGZp bmQgYSBJc29jaHJvbm91cyBkZXZpY2Ugd2l0aCBhbgp1cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5n dGggPD0gOCBieXRlcy4KClRoZSBpbXBsZW1lbnRhdGlvbiB0YWtlcyBpbnRvIGFjY291bnQgdGhh dCB0aGUgOCBieXRlIGJ1ZmZlcnMgcHJvdmlkZWQKYnkgdGhlIFVSQiB3aWxsIG5ldmVyIGNyb3Nz IGEgNjRLQiBib3VuZGFyeS4KClNpZ25lZC1vZmYtYnk6IE5pY29sYXMgU2FlbnogSnVsaWVubmUg PG5zYWVuemp1bGllbm5lQHN1c2UuZGU+ClJldmlld2VkLWJ5OiBGZWxpcGUgQmFsYmkgPGZlbGlw ZS5iYWxiaUBsaW51eC5pbnRlbC5jb20+ClNpZ25lZC1vZmYtYnk6IE1hdGhpYXMgTnltYW4gPG1h dGhpYXMubnltYW5AbGludXguaW50ZWwuY29tPgotLS0KIGRyaXZlcnMvdXNiL2hvc3QveGhjaS1y aW5nLmMgfCAxMiArKysrKysrKysrKysKIGRyaXZlcnMvdXNiL2hvc3QveGhjaS5jICAgICAgfCAx NiArKysrKysrKysrKysrKysrCiBkcml2ZXJzL3VzYi9ob3N0L3hoY2kuaCAgICAgIHwgMTcgKysr KysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNDUgaW5zZXJ0aW9ucygrKQoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvdXNiL2hvc3QveGhjaS1yaW5nLmMgYi9kcml2ZXJzL3VzYi9ob3N0L3ho Y2ktcmluZy5jCmluZGV4IDkyMTVhMjguLjI4MjUwMzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNi L2hvc3QveGhjaS1yaW5nLmMKKysrIGIvZHJpdmVycy91c2IvaG9zdC94aGNpLXJpbmcuYwpAQCAt MzI3NSw2ICszMjc1LDEyIEBAIGludCB4aGNpX3F1ZXVlX2J1bGtfdHgoc3RydWN0IHhoY2lfaGNk ICp4aGNpLCBnZnBfdCBtZW1fZmxhZ3MsCiAJCQlmaWVsZCB8PSBUUkJfSU9DOwogCQkJbW9yZV90 cmJzX2NvbWluZyA9IGZhbHNlOwogCQkJdGQtPmxhc3RfdHJiID0gcmluZy0+ZW5xdWV1ZTsKKwor CQkJaWYgKHhoY2lfdXJiX3N1aXRhYmxlX2Zvcl9pZHQodXJiKSkgeworCQkJCW1lbWNweSgmc2Vu ZF9hZGRyLCB1cmItPnRyYW5zZmVyX2J1ZmZlciwKKwkJCQkgICAgICAgdHJiX2J1ZmZfbGVuKTsK KwkJCQlmaWVsZCB8PSBUUkJfSURUOworCQkJfQogCQl9CiAKIAkJLyogT25seSBzZXQgaW50ZXJy dXB0IG9uIHNob3J0IHBhY2tldCBmb3IgSU4gZW5kcG9pbnRzICovCkBAIC0zNDE0LDYgKzM0MjAs MTIgQEAgaW50IHhoY2lfcXVldWVfY3RybF90eChzdHJ1Y3QgeGhjaV9oY2QgKnhoY2ksIGdmcF90 IG1lbV9mbGFncywKIAlpZiAodXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoID4gMCkgewogCQl1 MzIgbGVuZ3RoX2ZpZWxkLCByZW1haW5kZXI7CiAKKwkJaWYgKHhoY2lfdXJiX3N1aXRhYmxlX2Zv cl9pZHQodXJiKSkgeworCQkJbWVtY3B5KCZ1cmItPnRyYW5zZmVyX2RtYSwgdXJiLT50cmFuc2Zl cl9idWZmZXIsCisJCQkgICAgICAgdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoKTsKKwkJCWZp ZWxkIHw9IFRSQl9JRFQ7CisJCX0KKwogCQlyZW1haW5kZXIgPSB4aGNpX3RkX3JlbWFpbmRlcih4 aGNpLCAwLAogCQkJCXVyYi0+dHJhbnNmZXJfYnVmZmVyX2xlbmd0aCwKIAkJCQl1cmItPnRyYW5z ZmVyX2J1ZmZlcl9sZW5ndGgsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuYyBi L2RyaXZlcnMvdXNiL2hvc3QveGhjaS5jCmluZGV4IDdmYTU4YzkuLjI1NWY5M2YgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5j CkBAIC0xMjM4LDYgKzEyMzgsMjEgQEAgRVhQT1JUX1NZTUJPTF9HUEwoeGhjaV9yZXN1bWUpOwog CiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0qLwogCisvKgorICogQnlwYXNzIHRoZSBETUEgbWFwcGluZyBp ZiBVUkIgaXMgc3VpdGFibGUgZm9yIEltbWVkaWF0ZSBUcmFuc2ZlciAoSURUKSwKKyAqIHdlJ2xs IGNvcHkgdGhlIGFjdHVhbCBkYXRhIGludG8gdGhlIFRSQiBhZGRyZXNzIHJlZ2lzdGVyLiBUaGlz IGlzIGxpbWl0ZWQgdG8KKyAqIHRyYW5zZmVycyB1cCB0byA4IGJ5dGVzIG9uIG91dHB1dCBlbmRw b2ludHMgb2YgYW55IGtpbmQgd2l0aCB3TWF4UGFja2V0U2l6ZQorICogPj0gOCBieXRlcy4gSWYg c3VpdGFibGUgZm9yIElEVCBvbmx5IG9uZSBUcmFuc2ZlciBUUkIgcGVyIFREIGlzIGFsbG93ZWQu CisgKi8KK3N0YXRpYyBpbnQgeGhjaV9tYXBfdXJiX2Zvcl9kbWEoc3RydWN0IHVzYl9oY2QgKmhj ZCwgc3RydWN0IHVyYiAqdXJiLAorCQkJCWdmcF90IG1lbV9mbGFncykKK3sKKwlpZiAoeGhjaV91 cmJfc3VpdGFibGVfZm9yX2lkdCh1cmIpKQorCQlyZXR1cm4gMDsKKworCXJldHVybiB1c2JfaGNk X21hcF91cmJfZm9yX2RtYShoY2QsIHVyYiwgbWVtX2ZsYWdzKTsKK30KKwogLyoqCiAgKiB4aGNp X2dldF9lbmRwb2ludF9pbmRleCAtIFVzZWQgZm9yIHBhc3NpbmcgZW5kcG9pbnQgYml0bWFza3Mg YmV0d2VlbiB0aGUgY29yZSBhbmQKICAqIEhDRHMuICBGaW5kIHRoZSBpbmRleCBmb3IgYW4gZW5k cG9pbnQgZ2l2ZW4gaXRzIGRlc2NyaXB0b3IuICBVc2UgdGhlIHJldHVybgpAQCAtNTE1NCw2ICs1 MTY5LDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBoY19kcml2ZXIgeGhjaV9oY19kcml2ZXIgPSB7 CiAJLyoKIAkgKiBtYW5hZ2luZyBpL28gcmVxdWVzdHMgYW5kIGFzc29jaWF0ZWQgZGV2aWNlIHJl c291cmNlcwogCSAqLworCS5tYXBfdXJiX2Zvcl9kbWEgPSAgICAgIHhoY2lfbWFwX3VyYl9mb3Jf ZG1hLAogCS51cmJfZW5xdWV1ZSA9CQl4aGNpX3VyYl9lbnF1ZXVlLAogCS51cmJfZGVxdWV1ZSA9 CQl4aGNpX3VyYl9kZXF1ZXVlLAogCS5hbGxvY19kZXYgPQkJeGhjaV9hbGxvY19kZXYsCmRpZmYg LS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuaCBiL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5o CmluZGV4IDkzMzRjZGUuLmFiYmQ0ODEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3QveGhj aS5oCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5oCkBAIC0xMzAzLDYgKzEzMDMsOCBAQCBl bnVtIHhoY2lfc2V0dXBfZGV2IHsKICNkZWZpbmUgVFJCX0lPQwkJCSgxPDw1KQogLyogVGhlIGJ1 ZmZlciBwb2ludGVyIGNvbnRhaW5zIGltbWVkaWF0ZSBkYXRhICovCiAjZGVmaW5lIFRSQl9JRFQJ CQkoMTw8NikKKy8qIFREcyBzbWFsbGVyIHRoYW4gdGhpcyBtaWdodCB1c2UgSURUICovCisjZGVm aW5lIFRSQl9JRFRfTUFYX1NJWkUJOAogCiAvKiBCbG9jayBFdmVudCBJbnRlcnJ1cHQgKi8KICNk ZWZpbmUJVFJCX0JFSQkJCSgxPDw5KQpAQCAtMjE0OSw2ICsyMTUxLDIxIEBAIHN0YXRpYyBpbmxp bmUgc3RydWN0IHhoY2lfcmluZyAqeGhjaV91cmJfdG9fdHJhbnNmZXJfcmluZyhzdHJ1Y3QgeGhj aV9oY2QgKnhoY2ksCiAJCQkJCXVyYi0+c3RyZWFtX2lkKTsKIH0KIAorLyoKKyAqIFRPRE86IEFz IHBlciBzcGVjIElzb2Nocm9ub3VzIElEVCB0cmFuc21pc3Npb25zIGFyZSBzdXBwb3J0ZWQuIFdl IGJ5cGFzcworICogdGhlbSBhbnl3YXlzIGFzIHdlIHdoZXJlIHVuYWJsZSB0byBmaW5kIGEgZGV2 aWNlIHRoYXQgbWF0Y2hlcyB0aGUKKyAqIGNvbnN0cmFpbnRzLgorICovCitzdGF0aWMgaW5saW5l IGJvb2wgeGhjaV91cmJfc3VpdGFibGVfZm9yX2lkdChzdHJ1Y3QgdXJiICp1cmIpCit7CisJaWYg KCF1c2JfZW5kcG9pbnRfeGZlcl9pc29jKCZ1cmItPmVwLT5kZXNjKSAmJiB1c2JfdXJiX2Rpcl9v dXQodXJiKSAmJgorCSAgICB1c2JfZW5kcG9pbnRfbWF4cCgmdXJiLT5lcC0+ZGVzYykgPj0gVFJC X0lEVF9NQVhfU0laRSAmJgorCSAgICB1cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGggPD0gVFJC X0lEVF9NQVhfU0laRSkKKwkJcmV0dXJuIHRydWU7CisKKwlyZXR1cm4gZmFsc2U7Cit9CisKIHN0 YXRpYyBpbmxpbmUgY2hhciAqeGhjaV9zbG90X3N0YXRlX3N0cmluZyh1MzIgc3RhdGUpCiB7CiAJ c3dpdGNoIChzdGF0ZSkgewo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.9 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 783D0C43219 for ; Fri, 26 Apr 2019 13:21:11 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 52F1B2077B for ; Fri, 26 Apr 2019 13:21:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726176AbfDZNVK (ORCPT ); Fri, 26 Apr 2019 09:21:10 -0400 Received: from mga03.intel.com ([134.134.136.65]:37097 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726013AbfDZNVK (ORCPT ); Fri, 26 Apr 2019 09:21:10 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga103.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 26 Apr 2019 06:21:10 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.60,397,1549958400"; d="scan'208";a="168185691" Received: from mattu-haswell.fi.intel.com ([10.237.72.164]) by fmsmga001.fm.intel.com with ESMTP; 26 Apr 2019 06:21:08 -0700 From: Mathias Nyman To: Cc: , Nicolas Saenz Julienne , Mathias Nyman Subject: [PATCH 1/4] usb: xhci: add Immediate Data Transfer support Date: Fri, 26 Apr 2019 16:23:29 +0300 Message-Id: <1556285012-28186-2-git-send-email-mathias.nyman@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1556285012-28186-1-git-send-email-mathias.nyman@linux.intel.com> References: <1556285012-28186-1-git-send-email-mathias.nyman@linux.intel.com> Sender: linux-usb-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-usb@vger.kernel.org Content-Type: text/plain; charset="UTF-8" Message-ID: <20190426132329.Ntdn1xN-JdrCwcWgZ8zrL9xjrwl-6gC9voTzA2OsxZQ@z> From: Nicolas Saenz Julienne Immediate data transfers (IDT) allow the HCD to copy small chunks of data (up to 8bytes) directly into its output transfer TRBs. This avoids the somewhat expensive DMA mappings that are performed by default on most URBs submissions. In the case an URB was suitable for IDT. The data is directly copied into the "Data Buffer Pointer" region of the TRB and the IDT flag is set. Instead of triggering memory accesses the HC will use the data directly. The implementation could cover all kind of output endpoints. Yet Isochronous endpoints are bypassed as I was unable to find one that matched IDT's constraints. As we try to bypass the default DMA mappings on URB buffers we'd need to find a Isochronous device with an urb->transfer_buffer_length <= 8 bytes. The implementation takes into account that the 8 byte buffers provided by the URB will never cross a 64KB boundary. Signed-off-by: Nicolas Saenz Julienne Reviewed-by: Felipe Balbi Signed-off-by: Mathias Nyman --- drivers/usb/host/xhci-ring.c | 12 ++++++++++++ drivers/usb/host/xhci.c | 16 ++++++++++++++++ drivers/usb/host/xhci.h | 17 +++++++++++++++++ 3 files changed, 45 insertions(+) diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c index 9215a28..2825031 100644 --- a/drivers/usb/host/xhci-ring.c +++ b/drivers/usb/host/xhci-ring.c @@ -3275,6 +3275,12 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags, field |= TRB_IOC; more_trbs_coming = false; td->last_trb = ring->enqueue; + + if (xhci_urb_suitable_for_idt(urb)) { + memcpy(&send_addr, urb->transfer_buffer, + trb_buff_len); + field |= TRB_IDT; + } } /* Only set interrupt on short packet for IN endpoints */ @@ -3414,6 +3420,12 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, if (urb->transfer_buffer_length > 0) { u32 length_field, remainder; + if (xhci_urb_suitable_for_idt(urb)) { + memcpy(&urb->transfer_dma, urb->transfer_buffer, + urb->transfer_buffer_length); + field |= TRB_IDT; + } + remainder = xhci_td_remainder(xhci, 0, urb->transfer_buffer_length, urb->transfer_buffer_length, diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c index 7fa58c9..255f93f 100644 --- a/drivers/usb/host/xhci.c +++ b/drivers/usb/host/xhci.c @@ -1238,6 +1238,21 @@ EXPORT_SYMBOL_GPL(xhci_resume); /*-------------------------------------------------------------------------*/ +/* + * Bypass the DMA mapping if URB is suitable for Immediate Transfer (IDT), + * we'll copy the actual data into the TRB address register. This is limited to + * transfers up to 8 bytes on output endpoints of any kind with wMaxPacketSize + * >= 8 bytes. If suitable for IDT only one Transfer TRB per TD is allowed. + */ +static int xhci_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, + gfp_t mem_flags) +{ + if (xhci_urb_suitable_for_idt(urb)) + return 0; + + return usb_hcd_map_urb_for_dma(hcd, urb, mem_flags); +} + /** * xhci_get_endpoint_index - Used for passing endpoint bitmasks between the core and * HCDs. Find the index for an endpoint given its descriptor. Use the return @@ -5154,6 +5169,7 @@ static const struct hc_driver xhci_hc_driver = { /* * managing i/o requests and associated device resources */ + .map_urb_for_dma = xhci_map_urb_for_dma, .urb_enqueue = xhci_urb_enqueue, .urb_dequeue = xhci_urb_dequeue, .alloc_dev = xhci_alloc_dev, diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h index 9334cde..abbd481 100644 --- a/drivers/usb/host/xhci.h +++ b/drivers/usb/host/xhci.h @@ -1303,6 +1303,8 @@ enum xhci_setup_dev { #define TRB_IOC (1<<5) /* The buffer pointer contains immediate data */ #define TRB_IDT (1<<6) +/* TDs smaller than this might use IDT */ +#define TRB_IDT_MAX_SIZE 8 /* Block Event Interrupt */ #define TRB_BEI (1<<9) @@ -2149,6 +2151,21 @@ static inline struct xhci_ring *xhci_urb_to_transfer_ring(struct xhci_hcd *xhci, urb->stream_id); } +/* + * TODO: As per spec Isochronous IDT transmissions are supported. We bypass + * them anyways as we where unable to find a device that matches the + * constraints. + */ +static inline bool xhci_urb_suitable_for_idt(struct urb *urb) +{ + if (!usb_endpoint_xfer_isoc(&urb->ep->desc) && usb_urb_dir_out(urb) && + usb_endpoint_maxp(&urb->ep->desc) >= TRB_IDT_MAX_SIZE && + urb->transfer_buffer_length <= TRB_IDT_MAX_SIZE) + return true; + + return false; +} + static inline char *xhci_slot_state_string(u32 state) { switch (state) { -- 2.7.4