* [PATCH v5] HID: intel-thc-hid: intel-thc: restore PRD table capacity
@ 2026-11-17 9:32 Emfox Zhou
2026-11-17 9:46 ` sashiko-bot
0 siblings, 1 reply; 2+ messages in thread
From: Emfox Zhou @ 2026-11-17 9:32 UTC (permalink / raw)
To: Even Xu, Xinpeng Sun, Jiri Kosina, Benjamin Tissoires
Cc: linux-input, linux-kernel
The controller writes the frame length into the PRD entry it filled and
marks the end of the frame there; only a read puts the capacity back.
thc_reset_dma_settings() rewinds the read pointers but not those lengths,
and stops the engines: a frame still queued when it runs is dropped, the
next frame that does not fit runs past the end of its entry, and the
controller reports a buffer overrun. That is a transfer error and leads
back into the same reset, with the table still short.
Rebuild a table before the engine that reads it is started: for probe,
resume and the RxDMA reset, for the SWDMA start once that engine reports
idle (a timed-out transfer leaves it running), and for the receive tables
where an SWDMA round trip restarts the receive engine.
A drain in the threaded handler reads a table without the bus lock, so a
rebuild can land in the middle of it. The tables get a mutex taken by the
rebuild, by that drain and by the arming, inside the bus lock where the
caller holds it; no path takes the two in the other order.
The rewind leaves the read pointer at the start and the write pointer
where the last frame left it, so the ring reads as non-empty while the
engine is stopped and a drain would take an entry that was never written.
Record whether an engine runs, and read the ring only while it is set: the
flag is published under that same lock, after the control register is read
back, so a drain sees either a stopped engine or an armed one.
thc_dma_read() leaves *read_len untouched when it takes nothing, which its
callers do not expect, and thc_copy_sgls_to_prd() returns early for a
channel whose tables are gone.
Fixes: a688404b2e20 ("HID: intel-thc-hid: intel-thc: Add THC DMA interfaces")
Signed-off-by: Emfox Zhou <emfox@debian.org>
---
Changes in v5:
- A read of the ring is refused while its engine is stopped: the rewind
moves the read pointer back but leaves the write pointer where the
last frame left it, so a drain arriving before the restart would take
an entry that was never written. The flag covers every channel that
reads the ring, SWDMA included, and is published under the read lock
after the arming, with the control register read back first.
- thc_dma_read() clears *read_len when it reads nothing.
Changes in v4:
- The tables are rebuilt under a mutex that the receive path takes as
well: the threaded handler drains the ring outside the bus lock, so a
rebuild could land in the middle of a read.
- The SWDMA table is rebuilt after its engine is waited for, and the
receive tables are rebuilt where an SWDMA round trip restarts the
receive engine.
Link: https://lore.kernel.org/r/20261117003247.940876-1-emfox@debian.org
---
.../intel-thc-hid/intel-thc/intel-thc-dma.c | 75 ++++++++++++++++++-
.../intel-thc-hid/intel-thc/intel-thc-dma.h | 7 ++
2 files changed, 81 insertions(+), 1 deletion(-)
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 c80ef8c20..e315989a4 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
@@ -30,10 +30,20 @@ static void dma_set_start_bit(struct thc_device *dev,
struct thc_dma_configuration *dma_config)
{
u32 ctrl, mask, mbits, data, offset;
+ bool reads_ring;
if (!dma_config->is_enabled)
return;
+ /*
+ * Arm and publish under the lock the read path takes: a ring that was
+ * just rewound still reads as non-empty, so a reader in between would
+ * copy an entry the engine never wrote. TxDMA reads no ring.
+ */
+ reads_ring = dma_config->dma_channel != THC_TXDMA;
+ if (reads_ring)
+ mutex_lock(&dev->dma_ctx->prd_lock);
+
switch (dma_config->dma_channel) {
case THC_RXDMA1:
case THC_RXDMA2:
@@ -92,6 +102,17 @@ static void dma_set_start_bit(struct thc_device *dev,
default:
break;
}
+
+ if (reads_ring) {
+ /*
+ * The mutex orders the flag, not the write to the device:
+ * read the register back so the arming lands first.
+ */
+ regmap_read(dev->thc_regmap, dma_config->dma_cntrl, &ctrl);
+
+ WRITE_ONCE(dma_config->is_started, true);
+ mutex_unlock(&dev->dma_ctx->prd_lock);
+ }
}
static void dma_set_prd_control(struct thc_device *dev, u8 entry_count, u8 cb_depth,
@@ -211,12 +232,27 @@ static void thc_copy_sgls_to_prd(struct thc_device *dev,
{
unsigned int i;
+ guard(mutex)(&dev->dma_ctx->prd_lock);
+
+ if (!config->is_enabled || !config->prd_tbls)
+ return;
+
memset(config->prd_tbls, 0, array_size(PRD_TABLE_SIZE, config->prd_tbl_num));
for (i = 0; i < config->prd_tbl_num; i++)
thc_copy_one_sgl_to_prd(dev, config, i);
}
+/*
+ * A frame that is never read leaves its entry short, and the engine reads
+ * the table again on every start: put the capacity back.
+ */
+static void thc_rebuild_rx_prd(struct thc_device *dev)
+{
+ thc_copy_sgls_to_prd(dev, &dev->dma_ctx->dma_config[THC_RXDMA1]);
+ thc_copy_sgls_to_prd(dev, &dev->dma_ctx->dma_config[THC_RXDMA2]);
+}
+
static int setup_dma_buffers(struct thc_device *dev,
struct thc_dma_configuration *config,
enum dma_data_direction dir)
@@ -266,6 +302,14 @@ static int setup_dma_buffers(struct thc_device *dev,
static void thc_reset_dma_settings(struct thc_device *dev)
{
+ struct thc_dma_context *dma_ctx = dev->dma_ctx;
+ int chan;
+
+ /* The rewind below discards the queue, so no read may start. */
+ if (dma_ctx)
+ for (chan = 0; chan < MAX_THC_DMA_CHANNEL; chan++)
+ WRITE_ONCE(dma_ctx->dma_config[chan].is_started, false);
+
/* Stop all DMA channels and reset DMA read pointers */
regmap_write_bits(dev->thc_regmap, THC_M_PRT_READ_DMA_CNTRL_1_OFFSET,
THC_M_PRT_READ_DMA_CNTRL_START, 0);
@@ -327,6 +371,7 @@ struct thc_dma_context *thc_dma_init(struct thc_device *dev)
return NULL;
dev->dma_ctx = dma_ctx;
+ mutex_init(&dma_ctx->prd_lock);
dma_ctx->dma_config[THC_RXDMA1].dma_channel = THC_RXDMA1;
dma_ctx->dma_config[THC_RXDMA2].dma_channel = THC_RXDMA2;
@@ -491,6 +536,9 @@ int thc_dma_configure(struct thc_device *dev)
return -EINVAL;
}
+ /* An entry may still be short from a frame nobody read. */
+ thc_rebuild_rx_prd(dev);
+
for (chan = 0; chan < MAX_THC_DMA_CHANNEL; chan++) {
dma_set_prd_base_addr(dev,
dma_ctx->dma_config[chan].prd_tbls_dma_handle,
@@ -520,6 +568,7 @@ void thc_dma_unconfigure(struct thc_device *dev)
int chan;
for (chan = 0; chan < MAX_THC_DMA_CHANNEL; chan++) {
+ WRITE_ONCE(dev->dma_ctx->dma_config[chan].is_started, false);
dma_set_prd_base_addr(dev, 0, &dev->dma_ctx->dma_config[chan]);
dma_clear_prd_control(dev, &dev->dma_ctx->dma_config[chan]);
}
@@ -541,6 +590,7 @@ static int thc_wait_for_dma_pause(struct thc_device *dev, enum thc_dma_channel c
((channel == THC_RXDMA2) ? THC_M_PRT_READ_DMA_CNTRL_2_OFFSET :
THC_M_PRT_READ_DMA_CNTRL_SW_OFFSET);
+ WRITE_ONCE(dev->dma_ctx->dma_config[channel].is_started, false);
regmap_write_bits(dev->thc_regmap, ctrl_reg, THC_M_PRT_READ_DMA_CNTRL_START, 0);
sts_reg = (channel == THC_RXDMA1) ? THC_M_PRT_READ_DMA_INT_STS_1_OFFSET :
@@ -685,6 +735,21 @@ static int thc_dma_read(struct thc_device *dev,
u8 read_ptr, write_ptr, prd_table_index;
int status;
+ /* The caller may look at this when nothing was read. */
+ *read_len = 0;
+
+ guard(mutex)(&dev->dma_ctx->prd_lock);
+
+ /*
+ * Nothing in the ring is ours until the engine is started: after a
+ * reset the pointers alone say nothing about what was written.
+ */
+ if (!READ_ONCE(read_config->is_started)) {
+ if (read_finished)
+ *read_finished = 1;
+ return 0;
+ }
+
if (!is_dma_buf_empty(dev, read_config, &read_ptr, &write_ptr)) {
prd_table_index = write_ptr & THC_POINTER_MASK;
@@ -765,11 +830,16 @@ 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_wait_for_dma_pause(dev, THC_RXDMA2) ||
+ thc_wait_for_dma_pause(dev, THC_SWDMA))
return -EIO;
thc_reset_dma_settings(dev);
+ /* A transfer that timed out left its frame length in the entry. */
+ thc_copy_sgls_to_prd(dev, &dev->dma_ctx->dma_config[THC_SWDMA]);
+
/*
* Max input size control feature is only available for RxDMA, it must keep disabled
* during SWDMA operation, and restore to previous state after SWDMA is done.
@@ -854,6 +924,9 @@ static int thc_swdma_read_completion(struct thc_device *dev)
thc_reset_dma_settings(dev);
+ /* The receive engine starts again just below. */
+ thc_rebuild_rx_prd(dev);
+
dma_set_start_bit(dev, &dev->dma_ctx->dma_config[THC_RXDMA2]);
ret = thc_interrupt_quiesce(dev, false);
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..16972d073 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
@@ -6,6 +6,7 @@
#include <linux/bits.h>
#include <linux/dma-mapping.h>
+#include <linux/mutex.h>
#include <linux/sizes.h>
#include <linux/time64.h>
#include <linux/types.h>
@@ -89,6 +90,7 @@ struct thc_prd_table {
* @dma_channel: DMA channel for current DMA configuration
* @prd_tbls_dma_handle: DMA buffer handle
* @dir: Direction of DMA for this config
+ * @is_started: The engine is running, so the ring may be read
* @prd_tbls: PRD tables for current DMA
* @sgls: Array of pointers to scatter-gather lists
* @sgls_nent_pages: Number of pages per scatter-gather list
@@ -105,6 +107,7 @@ struct thc_dma_configuration {
dma_addr_t prd_tbls_dma_handle;
enum dma_data_direction dir;
bool is_enabled;
+ bool is_started;
struct thc_prd_table *prd_tbls;
struct scatterlist *sgls[PRD_TABLES_NUM];
@@ -123,6 +126,7 @@ struct thc_dma_configuration {
* struct thc_dma_context - THC DMA context
* @thc_dma_configuration: Array of all THC Channel configures
* @use_write_interrupts: Indicate TxDMA using interrupt or polling
+ * @prd_lock: Serialises a table rebuild with the DMA read path
* @rx_max_size_en: Temp flag to indicate THC I2C Rx max input size control feature
* enabled or not, only be used during SWDMA operation.
* @rx_int_delay_en: Temp flag to indicate THC I2C Rx interrupt delay feature
@@ -132,6 +136,9 @@ struct thc_dma_context {
struct thc_dma_configuration dma_config[MAX_THC_DMA_CHANNEL];
u8 use_write_interrupts;
+ /* Taken inside the bus lock, never the other way round. */
+ struct mutex prd_lock;
+
bool rx_max_size_en;
bool rx_int_delay_en;
};
base-commit: aebb7274476403040d582c61478df8f4a7bf9cd3
^ permalink raw reply related [flat|nested] 2+ messages in thread* Re: [PATCH v5] HID: intel-thc-hid: intel-thc: restore PRD table capacity
2026-11-17 9:32 [PATCH v5] HID: intel-thc-hid: intel-thc: restore PRD table capacity Emfox Zhou
@ 2026-11-17 9:46 ` sashiko-bot
0 siblings, 0 replies; 2+ messages in thread
From: sashiko-bot @ 2026-11-17 9:46 UTC (permalink / raw)
To: Emfox Zhou; +Cc: linux-input, dmitry.torokhov
Thank you for your contribution! Sashiko AI review found 2 potential
issues to consider:
- [High] HID: intel-thc-hid: unlocked DMA stop and pointer rewind races
with thc_dma_read()
- [High] HID: intel-thc-hid: callers process stale buffer when
thc_dma_read() reads 0 bytes
--
commit e37dcedb282f37ff3f31a83e6e9909efb70e1d60
Author: Emfox Zhou <emfox@debian.org>
HID: intel-thc-hid: intel-thc: restore PRD table capacity
This commit reinitializes PRD tables before DMA engines are started,
serializes table rebuilds and ring reads with a mutex, and tracks whether
each DMA channel is running so stopped rings are not read.
Link: https://lore.kernel.org/r/20261117003247.940876-1-emfox@debian.org
> 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 c80ef8c205742..e315989a4c8fd 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
[ ... ]
> @@ -266,6 +302,14 @@ static int setup_dma_buffers(struct thc_device *dev,
>
> static void thc_reset_dma_settings(struct thc_device *dev)
> {
> + struct thc_dma_context *dma_ctx = dev->dma_ctx;
> + int chan;
> +
> + /* The rewind below discards the queue, so no read may start. */
> + if (dma_ctx)
> + for (chan = 0; chan < MAX_THC_DMA_CHANNEL; chan++)
> + WRITE_ONCE(dma_ctx->dma_config[chan].is_started, false);
> +
> /* Stop all DMA channels and reset DMA read pointers */
> regmap_write_bits(dev->thc_regmap, THC_M_PRT_READ_DMA_CNTRL_1_OFFSET,
> THC_M_PRT_READ_DMA_CNTRL_START, 0);
[Severity: High]
Can thc_reset_dma_settings() rewind the hardware read pointer while
thc_dma_read() is already past the is_started check?
thc_wait_for_dma_pause(), thc_reset_dma_settings() and
thc_dma_unconfigure() clear is_started and stop or rewind the channel
without taking dev->dma_ctx->prd_lock, while the threaded IRQ handler
drains THC_RXDMA2 outside dev->thc_bus_lock:
CPU0 CPU1
quickspi_irq_thread_handler() thc_swdma_read()
thc_rxdma_read() thc_swdma_read_start()
thc_dma_read() thc_wait_for_dma_pause(THC_RXDMA2)
guard(mutex)(&prd_lock) is_started = false
if (!READ_ONCE(is_started)) thc_reset_dma_settings()
/* rewinds TPCRP to 0 */
is_dma_buf_empty()
/* TPCRP == 0, TPCWP == 0x81 */
read_dma_buffer() <-- reads unwritten PRD entry
Because thc_copy_one_sgl_to_prd() restored that entry's length to
max_packet_size (ALIGN(size, SZ_4K)), read_dma_buffer() copies up to a
4K-aligned buffer into read_buff (overflowing qsdev->input_buf in
intel-quickspi when max_input_len is smaller than SZ_4K) and
update_write_pointer() corrupts TPCWP on the stopped ring. Similarly,
on probe error unwind, quicki2c_dma_deinit() and quickspi_dma_deinit()
call thc_dma_unconfigure() and thc_dma_release() before interrupts are
quiesced, which can unmap and free sgls and prd_tbls while an in-flight
thc_dma_read() is still using them under prd_lock.
Acquiring dev->dma_ctx->prd_lock when stopping the engines, rewinding
the pointers, and releasing the buffers would serialize against an
in-progress thc_dma_read().
[ ... ]
> @@ -685,6 +735,21 @@ static int thc_dma_read(struct thc_device *dev,
> u8 read_ptr, write_ptr, prd_table_index;
> int status;
>
> + /* The caller may look at this when nothing was read. */
> + *read_len = 0;
> +
> + guard(mutex)(&dev->dma_ctx->prd_lock);
> +
> + /*
> + * Nothing in the ring is ours until the engine is started: after a
> + * reset the pointers alone say nothing about what was written.
> + */
> + if (!READ_ONCE(read_config->is_started)) {
> + if (read_finished)
> + *read_finished = 1;
> + return 0;
> + }
> +
> if (!is_dma_buf_empty(dev, read_config, &read_ptr, &write_ptr)) {
> prd_table_index = write_ptr & THC_POINTER_MASK;
[Severity: High]
When thc_dma_read() returns 0 with *read_len = 0 and *read_finished = 1,
won't callers process stale data in read_buff?
If the threaded IRQ handler drains THC_RXDMA2 while the engine is paused
for an SWDMA transfer or reset, thc_rxdma_read() returns 0 without
touching the buffer, and neither caller checks for a zero length:
drivers/hid/intel-thc-hid/intel-quicki2c/pci-quicki2c.c:handle_input_report() {
while (!rx_dma_finished) {
ret = thc_rxdma_read(qcdev->thc_hw, THC_RXDMA2,
(u8 *)pkt, &report_len,
&rx_dma_finished);
if (ret)
return ret;
if (!pkt->len) {
...
quicki2c_hid_send_report(qcdev, pkt->data, qcdev->input_len,
HIDI2C_DATA_LEN(le16_to_cpu(pkt->len)));
}
}
handle_input_report() will either replay the previous packet in
qcdev->input_buf to the HID core or, if pkt->len was 0, falsely mark
qcdev->reset_ack = true. In intel-quickspi,
quickspi_irq_thread_handler() passes input_len == 0 to
quickspi_handle_input_data(), logging a false report length error, and
thc_swdma_read() returns 0 to quicki2c_get_report() and
quicki2c_get_report_descriptor() without populating read_buff.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261117093212.4122283-1-emfox@debian.org?part=1
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-11-17 9:46 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-17 9:32 [PATCH v5] HID: intel-thc-hid: intel-thc: restore PRD table capacity Emfox Zhou
2026-11-17 9:46 ` sashiko-bot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox