[RFC PATCH v3 2/5] HID: spi-hid: add spi-mem quad-SPI transfers

From
Jizhou Tong <hidden>
Date
2026-11-05 19:23:02
Also in
linux-devicetree, linux-spi, lkml
Reply to
Jizhou Tong, 2026-11-05
The Romulus13 touchpad uses single-lane opcodes followed by quad-lane
address and data phases. Describe these as spi-mem operations so the
controller receives the command, address, dummy and data phases explicitly.

Register both frontends through spi-mem while preserving ordinary SPI
transfers for single-lane devices. Controllers without mem_ops can use
the spi-mem fallback. Reject unsupported bus-width combinations and
require the four-byte opcode/address prefix only for quad output.

Signed-off-by: Jizhou Tong <redacted>
---
 drivers/hid/spi-hid/Kconfig        |  2 +-
 drivers/hid/spi-hid/spi-hid-acpi.c | 26 +++++-----
 drivers/hid/spi-hid/spi-hid-core.c | 77 +++++++++++++++++++++++-------
 drivers/hid/spi-hid/spi-hid-core.h |  1 +
 drivers/hid/spi-hid/spi-hid-of.c   | 29 +++++------
 drivers/hid/spi-hid/spi-hid.h      |  6 +--
 6 files changed, 92 insertions(+), 49 deletions(-)
diff --git a/drivers/hid/spi-hid/Kconfig b/drivers/hid/spi-hid/Kconfig
index 656dbda1c5..c84da18ab8 100644
--- a/drivers/hid/spi-hid/Kconfig
+++ b/drivers/hid/spi-hid/Kconfig
@@ -6,7 +6,7 @@
 menuconfig SPI_HID
 	tristate "SPI HID support"
 	default y
-	depends on SPI
+	depends on SPI && SPI_MEM
 
 if SPI_HID
 
diff --git a/drivers/hid/spi-hid/spi-hid-acpi.c b/drivers/hid/spi-hid/spi-hid-acpi.c
index ea291ca269..72e74da304 100644
--- a/drivers/hid/spi-hid/spi-hid-acpi.c
+++ b/drivers/hid/spi-hid/spi-hid-acpi.c
@@ -194,8 +194,9 @@ static void spi_hid_acpi_sleep_minimal_reset_delay(struct spihid_ops *ops)
 	fsleep(1000 * conf->minimal_reset_delay_ms);
 }
 
-static int spi_hid_acpi_probe(struct spi_device *spi)
+static int spi_hid_acpi_probe(struct spi_mem *mem)
 {
+	struct spi_device *spi = mem->spi;
 	struct device *dev = &spi->dev;
 	struct acpi_device *adev;
 	struct spi_hid_acpi_config *config;
@@ -232,7 +233,7 @@ static int spi_hid_acpi_probe(struct spi_device *spi)
 		return error;
 	}
 
-	return spi_hid_core_probe(spi, &config->ops, &config->property_conf);
+	return spi_hid_core_probe(mem, &config->ops, &config->property_conf);
 }
 
 static const struct acpi_device_id spi_hid_acpi_match[] = {
@@ -242,19 +243,20 @@ static const struct acpi_device_id spi_hid_acpi_match[] = {
 };
 MODULE_DEVICE_TABLE(acpi, spi_hid_acpi_match);
 
-static struct spi_driver spi_hid_acpi_driver = {
-	.driver = {
-		.name	= "spi_hid_acpi",
-		.owner	= THIS_MODULE,
-		.pm	= &spi_hid_core_pm,
-		.acpi_match_table = spi_hid_acpi_match,
-		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
+static struct spi_mem_driver spi_hid_acpi_driver = {
+	.spidrv = {
+		.driver = {
+			.name = "spi_hid_acpi",
+			.pm = &spi_hid_core_pm,
+			.acpi_match_table = spi_hid_acpi_match,
+			.probe_type = PROBE_PREFER_ASYNCHRONOUS,
+		},
 	},
-	.probe		= spi_hid_acpi_probe,
-	.remove		= spi_hid_core_remove,
+	.probe = spi_hid_acpi_probe,
+	.remove = spi_hid_core_remove,
 };
 
-module_spi_driver(spi_hid_acpi_driver);
+module_spi_mem_driver(spi_hid_acpi_driver);
 
 MODULE_DESCRIPTION("HID over SPI ACPI transport driver");
 MODULE_AUTHOR("Angela Czubak <aczubak@google.com>");
diff --git a/drivers/hid/spi-hid/spi-hid-core.c b/drivers/hid/spi-hid/spi-hid-core.c
index db04322517..53da68c705 100644
--- a/drivers/hid/spi-hid/spi-hid-core.c
+++ b/drivers/hid/spi-hid/spi-hid-core.c
@@ -216,7 +216,20 @@ static int spi_hid_input_sync(struct spi_hid *shid, void *buf, u16 length,
 				 shid->input_transfer[0].len,
 				 shid->input_transfer[1].rx_buf, 0, 0);
 
-	error = spi_sync(shid->spi, &shid->input_message);
+	if (shid->spi->mode & SPI_RX_QUAD) {
+		struct spi_mem_op op =
+			SPI_MEM_OP(SPI_MEM_OP_CMD(shid->conf->read_opcode, 1),
+				   SPI_MEM_OP_ADDR(3, is_header ?
+					shid->conf->input_report_header_address :
+					shid->conf->input_report_body_address, 4),
+				   SPI_MEM_OP_DUMMY(4, 4),
+				   SPI_MEM_OP_DATA_IN(length, rx, 4));
+
+		error = spi_mem_exec_op(shid->mem, &op);
+		shid->input_message.status = error;
+	} else {
+		error = spi_sync(shid->spi, &shid->input_message);
+	}
 	if (error) {
 		dev_err(&shid->spi->dev, "Error starting sync transfer: %d\n", error);
 		return error;
@@ -228,11 +241,28 @@ static int spi_hid_input_sync(struct spi_hid *shid, void *buf, u16 length,
 
 static int spi_hid_output(struct spi_hid *shid, const void *buf, u16 length)
 {
-	if (length > shid->xfer_size)
+	int error;
+
+	if (length > shid->xfer_size ||
+	    ((shid->spi->mode & SPI_TX_QUAD) && length < 4))
 		return -EMSGSIZE;
 
-	memcpy(shid->xfer_buf, buf, length);
-	return spi_write(shid->spi, shid->xfer_buf, length);
+	if (shid->spi->mode & SPI_TX_QUAD) {
+		struct spi_mem_op op =
+			SPI_MEM_OP(SPI_MEM_OP_CMD(shid->conf->write_opcode, 1),
+				   SPI_MEM_OP_ADDR(3, shid->conf->output_report_address, 4),
+				   SPI_MEM_OP_NO_DUMMY,
+				   SPI_MEM_OP_DATA_OUT(length - 4, shid->xfer_buf, 4));
+
+		/* spi-mem supplies the opcode and address outside the data phase. */
+		memcpy(shid->xfer_buf, (const u8 *)buf + 4, length - 4);
+		error = spi_mem_exec_op(shid->mem, &op);
+	} else {
+		memcpy(shid->xfer_buf, buf, length);
+		error = spi_write(shid->spi, shid->xfer_buf, length);
+	}
+
+	return error;
 }
 
 static const char *spi_hid_power_mode_string(enum hidspi_power_state power_state)
@@ -1280,7 +1310,7 @@ static void spi_hid_find_max_report(struct hid_device *hid, u32 type,
 static int spi_hid_ll_start(struct hid_device *hid)
 {
 	struct spi_device *spi = hid->driver_data;
-	struct spi_hid *shid = spi_get_drvdata(spi);
+	struct spi_hid *shid = spi_mem_get_drvdata(spi_get_drvdata(spi));
 	int error = 0;
 	/*
 	 * HID_MIN_BUFFER_SIZE is the minimum transport buffer size, not a
@@ -1314,7 +1344,7 @@ static void spi_hid_ll_stop(struct hid_device *hid)
 static int spi_hid_ll_open(struct hid_device *hid)
 {
 	struct spi_device *spi = hid->driver_data;
-	struct spi_hid *shid = spi_get_drvdata(spi);
+	struct spi_hid *shid = spi_mem_get_drvdata(spi_get_drvdata(spi));
 
 	set_bit(SPI_HID_STARTED, &shid->flags);
 	return 0;
@@ -1323,7 +1353,7 @@ static int spi_hid_ll_open(struct hid_device *hid)
 static void spi_hid_ll_close(struct hid_device *hid)
 {
 	struct spi_device *spi = hid->driver_data;
-	struct spi_hid *shid = spi_get_drvdata(spi);
+	struct spi_hid *shid = spi_mem_get_drvdata(spi_get_drvdata(spi));
 
 	clear_bit(SPI_HID_STARTED, &shid->flags);
 }
@@ -1331,7 +1361,7 @@ static void spi_hid_ll_close(struct hid_device *hid)
 static int spi_hid_ll_power(struct hid_device *hid, int level)
 {
 	struct spi_device *spi = hid->driver_data;
-	struct spi_hid *shid = spi_get_drvdata(spi);
+	struct spi_hid *shid = spi_mem_get_drvdata(spi_get_drvdata(spi));
 	int error = 0;
 
 	guard(mutex)(&shid->output_lock);
@@ -1344,7 +1374,7 @@ static int spi_hid_ll_power(struct hid_device *hid, int level)
 static int spi_hid_ll_parse(struct hid_device *hid)
 {
 	struct spi_device *spi = hid->driver_data;
-	struct spi_hid *shid = spi_get_drvdata(spi);
+	struct spi_hid *shid = spi_mem_get_drvdata(spi_get_drvdata(spi));
 	struct device *dev = &spi->dev;
 	unsigned int rsize = shid->desc.report_descriptor_length;
 	int error, len;
@@ -1391,7 +1421,7 @@ static int spi_hid_ll_output_report(struct hid_device *hid, __u8 *buf,
 				    size_t len)
 {
 	struct spi_device *spi = hid->driver_data;
-	struct spi_hid *shid = spi_get_drvdata(spi);
+	struct spi_hid *shid = spi_mem_get_drvdata(spi_get_drvdata(spi));
 	struct device *dev = &spi->dev;
 	struct spi_hid_output_report report = {
 		.report_type = OUTPUT_REPORT,
@@ -1424,7 +1454,7 @@ static int spi_hid_ll_raw_request(struct hid_device *hid,
 				  size_t len, unsigned char rtype, int reqtype)
 {
 	struct spi_device *spi = hid->driver_data;
-	struct spi_hid *shid = spi_get_drvdata(spi);
+	struct spi_hid *shid = spi_mem_get_drvdata(spi_get_drvdata(spi));
 	struct device *dev = &spi->dev;
 	int ret;
 
@@ -1589,9 +1619,10 @@ static int spi_hid_register_panel_follower(struct spi_hid *shid)
 	return drm_panel_add_follower(dev, &shid->panel_follower);
 }
 
-int spi_hid_core_probe(struct spi_device *spi, struct spihid_ops *ops,
+int spi_hid_core_probe(struct spi_mem *mem, struct spihid_ops *ops,
 		       struct spi_hid_conf *conf)
 {
+	struct spi_device *spi = mem->spi;
 	struct device *dev = &spi->dev;
 	struct spi_hid *shid;
 	int error;
@@ -1599,10 +1630,20 @@ int spi_hid_core_probe(struct spi_device *spi, struct spihid_ops *ops,
 	if (spi->irq <= 0)
 		return dev_err_probe(dev, spi->irq ?: -EINVAL, "Missing IRQ\n");
 
+	if ((spi->mode & (SPI_RX_QUAD | SPI_TX_QUAD)) &&
+	    (spi->mode & (SPI_RX_QUAD | SPI_TX_QUAD)) !=
+	    (SPI_RX_QUAD | SPI_TX_QUAD))
+		return dev_err_probe(dev, -EINVAL,
+				     "Quad mode needs four lanes in both directions\n");
+
+	if (spi->mode & (SPI_RX_DUAL | SPI_TX_DUAL | SPI_RX_OCTAL | SPI_TX_OCTAL))
+		return dev_err_probe(dev, -EOPNOTSUPP, "Unsupported SPI bus width\n");
+
 	shid = devm_kzalloc(dev, sizeof(*shid), GFP_KERNEL);
 	if (!shid)
 		return -ENOMEM;
 
+	shid->mem = mem;
 	shid->spi = spi;
 	shid->power_state = HIDSPI_OFF;
 	shid->ops = ops;
@@ -1610,7 +1651,7 @@ int spi_hid_core_probe(struct spi_device *spi, struct spihid_ops *ops,
 	set_bit(SPI_HID_RESET_PENDING, &shid->flags);
 	shid->is_panel_follower = drm_is_panel_follower(&spi->dev);
 
-	spi_set_drvdata(spi, shid);
+	spi_mem_set_drvdata(mem, shid);
 
 	/* Using now populated conf let's pre-calculate the read approvals */
 	spi_hid_populate_read_approvals(shid->conf, shid->read_approval_header,
@@ -1673,9 +1714,10 @@ int spi_hid_core_probe(struct spi_device *spi, struct spihid_ops *ops,
 }
 EXPORT_SYMBOL_GPL(spi_hid_core_probe);
 
-void spi_hid_core_remove(struct spi_device *spi)
+int spi_hid_core_remove(struct spi_mem *mem)
 {
-	struct spi_hid *shid = spi_get_drvdata(spi);
+	struct spi_device *spi = mem->spi;
+	struct spi_hid *shid = spi_mem_get_drvdata(mem);
 	struct device *dev = &spi->dev;
 	int error;
 
@@ -1700,12 +1742,13 @@ void spi_hid_core_remove(struct spi_device *spi)
 		if (error)
 			dev_err(dev, "failed to disable regulator: %d\n", error);
 	}
+	return 0;
 }
 EXPORT_SYMBOL_GPL(spi_hid_core_remove);
 
 static int spi_hid_core_pm_suspend(struct device *dev)
 {
-	struct spi_hid *shid = dev_get_drvdata(dev);
+	struct spi_hid *shid = spi_mem_get_drvdata(dev_get_drvdata(dev));
 
 	if (shid->is_panel_follower)
 		return 0;
@@ -1715,7 +1758,7 @@ static int spi_hid_core_pm_suspend(struct device *dev)
 
 static int spi_hid_core_pm_resume(struct device *dev)
 {
-	struct spi_hid *shid = dev_get_drvdata(dev);
+	struct spi_hid *shid = spi_mem_get_drvdata(dev_get_drvdata(dev));
 
 	if (shid->is_panel_follower)
 		return 0;
diff --git a/drivers/hid/spi-hid/spi-hid-core.h b/drivers/hid/spi-hid/spi-hid-core.h
index 3419472844..768d900bc7 100644
--- a/drivers/hid/spi-hid/spi-hid-core.h
+++ b/drivers/hid/spi-hid/spi-hid-core.h
@@ -44,6 +44,7 @@ struct spi_hid_device_descriptor {
 
 /* Driver context */
 struct spi_hid {
+	struct spi_mem *mem;
 	void *xfer_alloc;
 	u8 *xfer_buf;
 	size_t xfer_size;
diff --git a/drivers/hid/spi-hid/spi-hid-of.c b/drivers/hid/spi-hid/spi-hid-of.c
index 6de9affbeb..5148b6b1dd 100644
--- a/drivers/hid/spi-hid/spi-hid-of.c
+++ b/drivers/hid/spi-hid/spi-hid-of.c
@@ -142,8 +142,9 @@ static void spi_hid_of_sleep_minimal_reset_delay(struct spihid_ops *ops)
 	fsleep(1000 * conf->data.minimal_reset_delay_ms);
 }
 
-static int spi_hid_of_probe(struct spi_device *spi)
+static int spi_hid_of_probe(struct spi_mem *mem)
 {
+	struct spi_device *spi = mem->spi;
 	struct device *dev = &spi->dev;
 	const struct spi_hid_of_data *data;
 	struct spi_hid_of_config *config;
@@ -167,16 +168,11 @@ static int spi_hid_of_probe(struct spi_device *spi)
 
 	config->data = *data;
 
-	/*
-	 * FIXME: multi-SPI not supported. Once it is, derive the
-	 * HID-over-SPI flags from spi->mode.
-	 */
-
 	error = spi_hid_of_populate_config(config, dev);
 	if (error)
 		return dev_err_probe(dev, error, "Unable to populate config data\n");
 
-	return spi_hid_core_probe(spi, &config->ops, &config->data.conf);
+	return spi_hid_core_probe(mem, &config->ops, &config->data.conf);
 }
 
 static const struct of_device_id spi_hid_of_match[] = {
@@ -191,20 +187,21 @@ static const struct spi_device_id spi_hid_of_id_table[] = {
 };
 MODULE_DEVICE_TABLE(spi, spi_hid_of_id_table);
 
-static struct spi_driver spi_hid_of_driver = {
-	.driver = {
-		.name = "spi_hid_of",
-		.owner = THIS_MODULE,
-		.pm = &spi_hid_core_pm,
-		.of_match_table = spi_hid_of_match,
-		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
+static struct spi_mem_driver spi_hid_of_driver = {
+	.spidrv = {
+		.driver = {
+			.name = "spi_hid_of",
+			.pm = &spi_hid_core_pm,
+			.of_match_table = spi_hid_of_match,
+			.probe_type = PROBE_PREFER_ASYNCHRONOUS,
+		},
+		.id_table = spi_hid_of_id_table,
 	},
 	.probe = spi_hid_of_probe,
 	.remove = spi_hid_core_remove,
-	.id_table = spi_hid_of_id_table,
 };
 
-module_spi_driver(spi_hid_of_driver);
+module_spi_mem_driver(spi_hid_of_driver);
 
 MODULE_DESCRIPTION("HID over SPI OF transport driver");
 MODULE_AUTHOR("Dmitry Antipov <dmanti@microsoft.com>");
diff --git a/drivers/hid/spi-hid/spi-hid.h b/drivers/hid/spi-hid/spi-hid.h
index 95acb28452..e87d1cf05e 100644
--- a/drivers/hid/spi-hid/spi-hid.h
+++ b/drivers/hid/spi-hid/spi-hid.h
@@ -7,7 +7,7 @@
 #ifndef SPI_HID_H
 #define SPI_HID_H
 
-#include <linux/spi/spi.h>
+#include <linux/spi/spi-mem.h>
 #include <linux/sysfs.h>
 
 /* struct spi_hid_conf - Conf provided to the core */
@@ -35,10 +35,10 @@ struct spihid_ops {
 	void (*sleep_minimal_reset_delay)(struct spihid_ops *ops);
 };
 
-int spi_hid_core_probe(struct spi_device *spi, struct spihid_ops *ops,
+int spi_hid_core_probe(struct spi_mem *mem, struct spihid_ops *ops,
 		       struct spi_hid_conf *conf);
 
-void spi_hid_core_remove(struct spi_device *spi);
+int spi_hid_core_remove(struct spi_mem *mem);
 
 extern const struct dev_pm_ops spi_hid_core_pm;
 
Thread (56 messages) 56 messages, 6 authors, last reply 18h ago
Keyboard shortcuts
hback out one level
jnext message in thread / next series-diff position
kprevious message in thread / previous series-diff position
ldrill in
Escclose help / fold thread tree
?toggle this help