mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Emfox Zhou <emfox@debian.org>
To: Even Xu <even.xu@intel.com>, Xinpeng Sun <xinpeng.sun@intel.com>,
	Jiri Kosina <jikos@kernel.org>,
	Benjamin Tissoires <bentiss@kernel.org>
Cc: linux-input@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: [PATCH v2 5/5] HID: intel-thc-hid: intel-thc: budget the engine drain
Date: Wed, 18 Nov 2026 13:31:32 +0800	[thread overview]
Message-ID: <20261118053132.253448-6-emfox@debian.org> (raw)
In-Reply-To: <20261118053132.253448-1-emfox@debian.org>

thc_wait_for_dma_pause() gives every engine 10 ms to report idle, but a
receive engine can be draining a whole frame. Its buffer comes from the
HIDSPI device descriptor's max_input_len, rounded up to 4 KB and capped at
16 PRD entries, so up to 64 KB; at the 2.23 MHz gear that takes about
235 ms, and a timed out pause makes thc_rxdma_reset() return before the
engines are reconfigured, leaving the controller quiesced with the
interrupts off.

Let the callers pass the budget. thc_rxdma_reset() gets one that covers a
full frame at the slowest gear. The SWDMA path keeps the old one: it
pauses the receive engines with the bus lock held and the interrupts
quiesced, and its frames are small.

thc_dma_unconfigure() needs the same budget from the other side: it stops
all four engines but returns before they report idle, and the caller
releases the tables right after. Wait for them there too, or an engine
still writing reaches pages that are already back in the allocator.

Fixes: 1d46b8d40655 ("HID: Intel-thc-hid: Intel-thc: Add API to reset read DMA")
Signed-off-by: Emfox Zhou <emfox@debian.org>
---
 .../intel-thc-hid/intel-thc/intel-thc-dma.c   | 72 ++++++++++++++-----
 .../intel-thc-hid/intel-thc/intel-thc-dma.h   |  6 ++
 2 files changed, 61 insertions(+), 17 deletions(-)

diff --git a/drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c b/drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c
index 41efdfaf0..d182f3c42 100644
--- a/drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c
+++ b/drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c
@@ -514,6 +514,10 @@ int thc_dma_configure(struct thc_device *dev)
 }
 EXPORT_SYMBOL_NS_GPL(thc_dma_configure, "INTEL_THC");
 
+static int thc_wait_for_dma_pause(struct thc_device *dev,
+				  enum thc_dma_channel channel,
+				  u32 timeout_us);
+
 /**
  * thc_dma_unconfigure - Unconfigure DMA settings for all DMA engines
  *
@@ -525,9 +529,14 @@ void thc_dma_unconfigure(struct thc_device *dev)
 
 	/*
 	 * Stop the engines first: one that is running keeps writing through
-	 * a table whose base is already gone.
+	 * a table whose base is already gone. The start bit is only a
+	 * request, so let each engine drain the frame it has in flight
+	 * before the table it writes into goes away.
 	 */
 	thc_clear_start_bits(dev);
+	for (chan = 0; chan < MAX_THC_DMA_CHANNEL; chan++)
+		thc_wait_for_dma_pause(dev, (enum thc_dma_channel)chan,
+				       THC_DMA_DRAIN_US_TIMEOUT);
 
 	for (chan = 0; chan < MAX_THC_DMA_CHANNEL; chan++) {
 		dma_set_prd_base_addr(dev, 0, &dev->dma_ctx->dma_config[chan]);
@@ -536,25 +545,48 @@ void thc_dma_unconfigure(struct thc_device *dev)
 }
 EXPORT_SYMBOL_NS_GPL(thc_dma_unconfigure, "INTEL_THC");
 
-static int thc_wait_for_dma_pause(struct thc_device *dev, enum thc_dma_channel channel)
+static int thc_wait_for_dma_pause(struct thc_device *dev,
+				  enum thc_dma_channel channel,
+				  u32 timeout_us)
 {
-	u32 ctrl_reg, sts_reg, sts;
+	u32 ctrl_reg, ctrl_bit, sts_reg, sts_bit, sts;
 	int ret;
 
-	ctrl_reg = (channel == THC_RXDMA1) ? THC_M_PRT_READ_DMA_CNTRL_1_OFFSET :
-			((channel == THC_RXDMA2) ? THC_M_PRT_READ_DMA_CNTRL_2_OFFSET :
-						   THC_M_PRT_READ_DMA_CNTRL_SW_OFFSET);
-
-	regmap_write_bits(dev->thc_regmap, ctrl_reg, THC_M_PRT_READ_DMA_CNTRL_START, 0);
+	switch (channel) {
+	case THC_RXDMA1:
+		ctrl_reg = THC_M_PRT_READ_DMA_CNTRL_1_OFFSET;
+		sts_reg = THC_M_PRT_READ_DMA_INT_STS_1_OFFSET;
+		ctrl_bit = THC_M_PRT_READ_DMA_CNTRL_START;
+		sts_bit = THC_M_PRT_READ_DMA_INT_STS_ACTIVE;
+		break;
+	case THC_RXDMA2:
+		ctrl_reg = THC_M_PRT_READ_DMA_CNTRL_2_OFFSET;
+		sts_reg = THC_M_PRT_READ_DMA_INT_STS_2_OFFSET;
+		ctrl_bit = THC_M_PRT_READ_DMA_CNTRL_START;
+		sts_bit = THC_M_PRT_READ_DMA_INT_STS_ACTIVE;
+		break;
+	case THC_SWDMA:
+		ctrl_reg = THC_M_PRT_READ_DMA_CNTRL_SW_OFFSET;
+		sts_reg = THC_M_PRT_READ_DMA_INT_STS_SW_OFFSET;
+		ctrl_bit = THC_M_PRT_READ_DMA_CNTRL_START;
+		sts_bit = THC_M_PRT_READ_DMA_INT_STS_ACTIVE;
+		break;
+	case THC_TXDMA:
+		ctrl_reg = THC_M_PRT_WRITE_DMA_CNTRL_OFFSET;
+		sts_reg = THC_M_PRT_WRITE_INT_STS_OFFSET;
+		ctrl_bit = THC_M_PRT_WRITE_DMA_CNTRL_THC_WRDMA_START;
+		sts_bit = THC_M_PRT_WRITE_INT_STS_THC_WRDMA_ACTIVE;
+		break;
+	default:
+		return -EINVAL;
+	}
 
-	sts_reg = (channel == THC_RXDMA1) ? THC_M_PRT_READ_DMA_INT_STS_1_OFFSET :
-			((channel == THC_RXDMA2) ? THC_M_PRT_READ_DMA_INT_STS_2_OFFSET :
-						   THC_M_PRT_READ_DMA_INT_STS_SW_OFFSET);
+	regmap_write_bits(dev->thc_regmap, ctrl_reg, ctrl_bit, 0);
 
 	ret = regmap_read_poll_timeout(dev->thc_regmap, sts_reg, sts,
-				       !(sts & THC_M_PRT_READ_DMA_INT_STS_ACTIVE),
+				       !(sts & sts_bit),
 				       THC_DEFAULT_RXDMA_POLLING_US_INTERVAL,
-				       THC_DEFAULT_RXDMA_POLLING_US_TIMEOUT);
+				       timeout_us);
 
 	if (ret) {
 		dev_err_once(dev->dev,
@@ -588,13 +620,15 @@ int thc_rxdma_reset(struct thc_device *dev)
 		goto end;
 	}
 
-	ret = thc_wait_for_dma_pause(dev, THC_RXDMA1);
+	ret = thc_wait_for_dma_pause(dev, THC_RXDMA1,
+				     THC_DMA_DRAIN_US_TIMEOUT);
 	if (ret) {
 		dev_err(dev->dev, "Wait for RxDMA1 pause failed during RxDMA reset\n");
 		goto end;
 	}
 
-	ret = thc_wait_for_dma_pause(dev, THC_RXDMA2);
+	ret = thc_wait_for_dma_pause(dev, THC_RXDMA2,
+				     THC_DMA_DRAIN_US_TIMEOUT);
 	if (ret) {
 		dev_err(dev->dev, "Wait for RxDMA2 pause failed during RxDMA reset\n");
 		goto end;
@@ -769,7 +803,10 @@ static int thc_swdma_read_start(struct thc_device *dev, void *write_buff,
 	if (ret)
 		return ret;
 
-	if (thc_wait_for_dma_pause(dev, THC_RXDMA1) || thc_wait_for_dma_pause(dev, THC_RXDMA2))
+	if (thc_wait_for_dma_pause(dev, THC_RXDMA1,
+				   THC_DEFAULT_RXDMA_POLLING_US_TIMEOUT) ||
+	    thc_wait_for_dma_pause(dev, THC_RXDMA2,
+				   THC_DEFAULT_RXDMA_POLLING_US_TIMEOUT))
 		return -EIO;
 
 	thc_reset_dma_settings(dev);
@@ -834,7 +871,8 @@ static int thc_swdma_read_completion(struct thc_device *dev)
 {
 	int ret;
 
-	ret = thc_wait_for_dma_pause(dev, THC_SWDMA);
+	ret = thc_wait_for_dma_pause(dev, THC_SWDMA,
+				     THC_DEFAULT_RXDMA_POLLING_US_TIMEOUT);
 	if (ret)
 		return ret;
 
diff --git a/drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.h b/drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.h
index 715423453..fa4cdc380 100644
--- a/drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.h
+++ b/drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.h
@@ -19,6 +19,12 @@
 #define THC_DEFAULT_RXDMA_POLLING_US_INTERVAL 100
 #define THC_DEFAULT_RXDMA_POLLING_US_TIMEOUT  (10 * USEC_PER_MSEC)
 
+/*
+ * A 64 KB frame takes 235 ms at the slowest gear, so 500 ms covers one with
+ * room to spare.
+ */
+#define THC_DMA_DRAIN_US_TIMEOUT  (500 * USEC_PER_MSEC)
+
 /*
  * THC needs 1KB aligned address, dest_addr is 54 bits, not 64,
  * so don't need to send the lower 10-bits of address.

      parent reply	other threads:[~2026-11-18  5:32 UTC|newest]

Thread overview: 6+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-18  5:31 [PATCH v2 0/5] HID: intel-thc-hid: intel-thc: DMA lifetime fixes Emfox Zhou
2026-11-18  5:31 ` [PATCH v2 1/5] HID: intel-thc-hid: intel-thc: keep TxDMA write errors Emfox Zhou
2026-11-18  5:31 ` [PATCH v2 2/5] HID: intel-thc-hid: intel-thc: free the failed channel Emfox Zhou
2026-11-18  5:31 ` [PATCH v2 3/5] HID: intel-thc-hid: intel-thc: stop all engines first Emfox Zhou
2026-11-18  5:31 ` [PATCH v2 4/5] HID: intel-thc-hid: intel-thc: add the slow SPI gears Emfox Zhou
2026-11-18  5:31 ` Emfox Zhou [this message]

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261118053132.253448-6-emfox@debian.org \
    --to=emfox@debian.org \
    --cc=bentiss@kernel.org \
    --cc=even.xu@intel.com \
    --cc=jikos@kernel.org \
    --cc=linux-input@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=xinpeng.sun@intel.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®