mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Prakriti Sharma <Prakriti.Sharma@synopsys.com>
To: Mark Brown <broonie@kernel.org>, linux-spi@vger.kernel.org
Cc: Rob Herring <robh@kernel.org>,
	Krzysztof Kozlowski <krzk+dt@kernel.org>,
	Conor Dooley <conor+dt@kernel.org>,
	devicetree@vger.kernel.org,
	Philipp Zabel <p.zabel@pengutronix.de>,
	linux-kernel@vger.kernel.org,
	Siddhant Kumar <Siddhant.Kumar@synopsys.com>,
	Prakriti Sharma <Prakriti.Sharma@synopsys.com>
Subject: [PATCH 2/6] spi: dw-g2: Add Synopsys DWC SSI v2.02a driver
Date: Thu, 19 Nov 2026 15:35:09 +0530	[thread overview]
Message-ID: <20261119100513.433044-3-prakriti@synopsys.com> (raw)
In-Reply-To: <20261119100513.433044-1-prakriti@synopsys.com>

Add a driver for the Synopsys DesignWare SSI Gen2 (DWC_ssi v2.02a)
controller. Support probe, the MMIO glue, command-only transfers, and
short register operations.

Transfers are polled. The IRQ is claimed, including the optional
per-source rxf, txe, txaf, and wsf lines.

Signed-off-by: Prakriti Sharma <prakriti@synopsys.com>
Signed-off-by: Siddhant Kumar <sidkumar@synopsys.com>
---
 MAINTAINERS                  |   1 +
 drivers/spi/Kconfig          |  21 +
 drivers/spi/Makefile         |   3 +
 drivers/spi/spi-dw-g2-core.c | 896 +++++++++++++++++++++++++++++++++++
 drivers/spi/spi-dw-g2-mmio.c | 196 ++++++++
 drivers/spi/spi-dw-g2.h      | 396 ++++++++++++++++
 6 files changed, 1513 insertions(+)
 create mode 100644 drivers/spi/spi-dw-g2-core.c
 create mode 100644 drivers/spi/spi-dw-g2-mmio.c
 create mode 100644 drivers/spi/spi-dw-g2.h

diff --git a/MAINTAINERS b/MAINTAINERS
index e68a4337a651..e0f97d2792b1 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -27310,6 +27310,7 @@ M:	Siddhant Kumar <sidkumar@synopsys.com>
 L:	linux-spi@vger.kernel.org
 S:	Maintained
 F:	Documentation/devicetree/bindings/spi/snps,dwc-ssi-2.02a.yaml
+F:	drivers/spi/spi-dw-g2-*.[ch]
 
 SYNOPSYS HSDK RESET CONTROLLER DRIVER
 M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index a7b343d124a9..3c2a7ea543fd 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -381,6 +381,27 @@ config SPI_DESIGNWARE
 
 if SPI_DESIGNWARE
 
+config SPI_DW_SSI_G2
+	tristate "Synopsys Designware SSI Gen2 controller"
+	depends on SPI_DESIGNWARE
+	help
+	  Synopsys DesignWare SSI Gen2 is a SPI controller that supports
+	  standard, dual, quad, and octal SPI modes. It provides high
+	  performance SPI communication using the spi-mem interface.
+	  Enable this option if you have a device with a DW SSI Gen2
+	  controller and want to access SPI flash memories.
+
+config SPI_DW_SSI_G2_MMIO
+	tristate "Memory-mapped io interface driver for DW SSI Gen2 core"
+	depends on HAS_IOMEM
+	depends on SPI_DW_SSI_G2
+	help
+	  Memory-mapped I/O interface driver for the Synopsys DesignWare
+	  SSI Gen2 SPI controller. Enable this for platforms that access
+	  the controller registers via memory-mapped I/O. This is the
+	  most common access method for SoC-integrated instances of the
+	  DW SSI Gen2 controller.
+
 config SPI_DW_DMA
 	bool "DMA support for DW SPI controller"
 
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index b6ab37271555..f9c86827ebc2 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -57,6 +57,9 @@ spi-dw-y				:= spi-dw-core.o
 spi-dw-$(CONFIG_SPI_DW_DMA)		+= spi-dw-dma.o
 obj-$(CONFIG_SPI_DW_MMIO)		+= spi-dw-mmio.o
 obj-$(CONFIG_SPI_DW_PCI)		+= spi-dw-pci.o
+obj-$(CONFIG_SPI_DW_SSI_G2)		+= spi-dw-g2.o
+spi-dw-g2-y				:= spi-dw-g2-core.o
+obj-$(CONFIG_SPI_DW_SSI_G2_MMIO)     	+= spi-dw-g2-mmio.o
 obj-$(CONFIG_SPI_EP93XX)		+= spi-ep93xx.o
 obj-$(CONFIG_SPI_FALCON)		+= spi-falcon.o
 obj-$(CONFIG_SPI_FSI)			+= spi-fsi.o
diff --git a/drivers/spi/spi-dw-g2-core.c b/drivers/spi/spi-dw-g2-core.c
new file mode 100644
index 000000000000..7b0928f67103
--- /dev/null
+++ b/drivers/spi/spi-dw-g2-core.c
@@ -0,0 +1,896 @@
+// SPDX-License-Identifier: GPL-2.0-only OR MIT
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/of.h>
+#include <linux/delay.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/spi-mem.h>
+
+#include "spi-dw-g2.h"
+
+/*
+ * ========================================================================
+ * DebugFS support - exposes controller registers for debugging
+ * ========================================================================
+ */
+
+#ifdef CONFIG_DEBUG_FS
+#define DW_SPI_G2_DBG_REG(_name, _off) \
+	{ .name = _name, .offset = _off }
+
+static const struct debugfs_reg32 dw_spi_g2_dbg_regs[] = {
+	DW_SPI_G2_DBG_REG("SSIENR",         DW_SPI_G2_SSIENR),
+	DW_SPI_G2_DBG_REG("SLAVE_EN",       DW_SPI_G2_SER),
+	DW_SPI_G2_DBG_REG("CTRLR0_CS1",     DW_SPI_G2_CTRLR0(1)),
+	DW_SPI_G2_DBG_REG("CTRLR1_CS1",     DW_SPI_G2_CTRLR1(1)),
+	DW_SPI_G2_DBG_REG("SPI_CTRLR0_CS1", DW_SPI_G2_SPI_CTRLR0(1)),
+	DW_SPI_G2_DBG_REG("SPI_CTRLR1_CS1", DW_SPI_G2_SPI_CTRLR1(1)),
+	DW_SPI_G2_DBG_REG("BAUDR1",         DW_SPI_G2_BAUDR(1)),
+	DW_SPI_G2_DBG_REG("TXFTLR",         DW_SPI_G2_TXFTLR),
+	DW_SPI_G2_DBG_REG("RXFTLR",         DW_SPI_G2_RXFTLR),
+	DW_SPI_G2_DBG_REG("TXFLR",          DW_SPI_G2_TXFLR),
+	DW_SPI_G2_DBG_REG("RXFLR",          DW_SPI_G2_RXFLR),
+	DW_SPI_G2_DBG_REG("SR",             DW_SPI_G2_SR),
+	DW_SPI_G2_DBG_REG("IMR",            DW_SPI_G2_IMR),
+	DW_SPI_G2_DBG_REG("ISR",            DW_SPI_G2_ISR),
+	DW_SPI_G2_DBG_REG("DEDICATED_CS",   DW_SPI_G2_DEDICATED_CS_EN),
+};
+
+/**
+ * dw_spi_g2_debugfs_init - Create debugfs entries for register inspection
+ * @dws: Driver state
+ *
+ * Creates a debugfs directory at /sys/kernel/debug/dw_spi_g2.<bus_num>/
+ * with a "registers" file showing current controller register values.
+ * Useful for debugging transfer issues or verifying configuration.
+ */
+static void dw_spi_g2_debugfs_init(struct dw_spi_g2 *dws)
+{
+	char name[32];
+
+	snprintf(name, sizeof(name), "dw_spi_g2.%d", dws->ctlr->bus_num);
+
+	dws->debugfs = debugfs_create_dir(name, NULL);
+	if (!dws->debugfs)
+		return;
+
+	dws->regset.base = dws->regs;
+	dws->regset.regs = dw_spi_g2_dbg_regs;
+	dws->regset.nregs = ARRAY_SIZE(dw_spi_g2_dbg_regs);
+
+	debugfs_create_regset32("registers", 0400, dws->debugfs, &dws->regset);
+}
+
+/**
+ * dw_spi_g2_debugfs_remove - Remove debugfs entries
+ * @dws: Driver state
+ */
+static void dw_spi_g2_debugfs_remove(struct dw_spi_g2 *dws)
+{
+	debugfs_remove_recursive(dws->debugfs);
+	dws->debugfs = NULL;
+}
+#else
+static inline void dw_spi_g2_debugfs_init(struct dw_spi_g2 *dws)
+{
+}
+
+static inline void dw_spi_g2_debugfs_remove(struct dw_spi_g2 *dws)
+{
+}
+#endif
+
+/*
+ * ========================================================================
+ * SPI controller setup and initialization
+ * ========================================================================
+ */
+
+/**
+ * dw_spi_g2_setup - Configure baud rate for a specific SPI device
+ * @spi: SPI device being configured
+ *
+ * Called when a SPI device is added or its parameters change. Calculates
+ * and programs the baud rate divider for the device's requested speed.
+ *
+ * The baud rate register (BAUDR) uses an even divisor:
+ *   actual_speed = ssi_clk / BAUDR
+ *   BAUDR = 1 is a special case (passthrough, no division)
+ *   BAUDR must be even for values > 1
+ *
+ * Per-CS registers are written with the CS register block disabled
+ * (DEDICATED_CS_EN bit cleared) to ensure the write takes effect.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+int dw_spi_g2_setup(struct spi_device *spi)
+{
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(spi->controller);
+	u32 baud, speed, div, min_speed;
+
+	/* Get primary chip select (index 0 = first CS of this device) */
+	dws->cs = spi_get_chipselect(spi, 0);
+
+	/*
+	 * Calculate minimum achievable speed: slowest speed occurs at
+	 * maximum baud divisor (clk_rate / MAX_BAUDR).
+	 */
+	min_speed = DIV_ROUND_UP(dws->clk_rate, DW_SPI_G2_MAX_BAUDR);
+
+	/* Determine target speed (capped at controller maximum) */
+	speed = spi->max_speed_hz;
+	if (!speed || speed > dws->max_freq)
+		speed = dws->max_freq;
+
+	/*
+	 * Clamp speed to achievable range. If requested speed is below
+	 * hardware minimum, clamp to min_speed
+	 */
+	if (speed < min_speed) {
+		dev_warn(&spi->dev, "speed %u Hz below minimum %u Hz, clamping\n",
+			 speed, min_speed);
+		speed = min_speed;
+	}
+
+	/*
+	 * Calculate baud rate divisor (must be even, except for 1).
+	 * Since speed >= min_speed, div is guaranteed <= MAX_BAUDR.
+	 */
+	div = DIV_ROUND_UP(dws->clk_rate, speed);
+	if (div <= 1) {
+		baud = 1;	/* Passthrough mode - no division */
+	} else {
+		if (div & 1)
+			div++;	/* Round up to next even number */
+		baud = div;
+	}
+
+	/* Write baud rate to per-CS register (with CS block disabled) */
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_target_disable(dws, dws->cs);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_BAUDR(dws->cs), baud);
+
+	dev_dbg(&spi->dev,
+		"setup: CS=%u mode=%u bpw=%u speed=%u baud=%u\n",
+		dws->cs, spi->mode, spi->bits_per_word, speed, baud);
+
+	return 0;
+}
+
+static void dw_spi_g2_controller_reset(struct dw_spi_g2 *dws)
+{
+	int drain = 0;
+
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SER, 0);
+	/* Clear all interrupts by writing 1s to defined ICR bits */
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_ICR, DW_SPI_G2_ICR_ALL);
+
+	/* Drain any stale RX data left from previous transfers */
+	while (dw_spi_g2_readl(dws->regs, DW_SPI_G2_RXFLR) > 0 &&
+	       drain < dws->fifo_len) {
+		(void)dw_spi_g2_readl(dws->regs, DW_SPI_G2_DR0);
+		drain++;
+	}
+}
+
+/**
+ * dw_spi_g2_build_ctrlr0 - Build CTRLR0 register value
+ * @dws: Driver state
+ * @tmod: Transfer mode (TR=0, TO=1, RO=2, EEPROM=3)
+ * @frf: Frame format (Standard=0, Dual=1, Quad=2, Octal=3)
+ *
+ * Constructs the CTRLR0 register value with transfer mode, frame format,
+ * data frame size, and SPI mode (CPOL/CPHA) settings.
+ *
+ * Return: Constructed CTRLR0 register value
+ */
+static u32 dw_spi_g2_build_ctrlr0(struct dw_spi_g2 *dws, u8 tmod, u8 frf)
+{
+	u32 ctrlr0 = 0;
+	u8 dfs;
+
+	if (!dws->curr_spi) {
+		dev_err(dws->dev, "curr_spi not set\n");
+		return 0;
+	}
+
+	dfs = dws->curr_spi->bits_per_word ? dws->curr_spi->bits_per_word : 8;
+
+	/*
+	 * Validate data frame size (DFS).
+	 * Hardware supports 8, 16, and 32-bit transfers (DFS_ENCODE values 7, 15, 31).
+	 * Current spi-mem implementation uses 8-bit only (per Linux framework).
+	 * For 16/32-bit support via legacy transfer_one path, additional
+	 * FIFO handling logic would be required.
+	 */
+	if (dfs != (DW_SPI_G2_DFS_8BIT + 1) &&
+	    dfs != (DW_SPI_G2_DFS_16BIT + 1) &&
+	    dfs != (DW_SPI_G2_DFS_32BIT + 1)) {
+		dev_err(dws->dev, "Unsupported DFS: %u (must be 8, 16, or 32)\n",
+			dfs);
+		return 0;
+	}
+
+	/* Validate FRF compatibility with DFS */
+	if (frf != DW_SPI_G2_FRF_STANDARD && dfs != (DW_SPI_G2_DFS_8BIT + 1)) {
+		dev_err(dws->dev,
+			"Multi-line SPI modes require 8-bit transfers (dfs=%u frf=%u)\n",
+			dfs, frf);
+		return 0;
+	}
+
+	ctrlr0 |=
+	    FIELD_PREP(DW_SPI_G2_CTRLR0_DFS_MASK, DW_SPI_G2_DFS_ENCODE(dfs));
+	ctrlr0 |= FIELD_PREP(DW_SPI_G2_CTRLR0_TMOD_MASK, tmod);
+	ctrlr0 |= FIELD_PREP(DW_SPI_G2_CTRLR0_FRF_MASK, frf);
+
+	return ctrlr0;
+}
+
+/**
+ * dw_spi_g2_get_frf - Determine frame format from operation bus widths
+ * @op: SPI memory operation
+ *
+ * Examines the command, address, and data bus widths to determine the
+ * widest mode in use, which defines the frame format.
+ *
+ * Return: Frame format
+ */
+static u32 dw_spi_g2_get_frf(const struct spi_mem_op *op)
+{
+	/* Use the widest bus mode across cmd/addr/data phases */
+	u32 width = max3(op->cmd.buswidth,
+			 op->addr.buswidth ? op->addr.buswidth : 1,
+			 op->data.buswidth ? op->data.buswidth : 1);
+
+	switch (width) {
+	case 2:
+		return DW_SPI_G2_FRF_DUAL;
+	case 4:
+		return DW_SPI_G2_FRF_QUAD;
+	case 8:
+		return DW_SPI_G2_FRF_OCTAL;
+	default:
+		return DW_SPI_G2_FRF_STANDARD;
+	}
+}
+
+/**
+ * dw_spi_g2_get_tt - Determine transfer type from operation bus widths
+ * @op: SPI memory operation
+ *
+ * The transfer type (TT) field in SPI_CTRLR0 defines which phases use
+ * multi-line mode. TT0 = standard (1-1-1), TT1 = data multi-line (1-1-x),
+ * TT2 = addr+data multi-line (1-x-x). TT3 (x-x-x) is not supported.
+ *
+ * Return: Transfer type value (0-2), or -EOPNOTSUPP for unsupported patterns
+ */
+static int dw_spi_g2_get_tt(const struct spi_mem_op *op)
+{
+	bool cmd_m = (op->cmd.buswidth > 1);
+	bool addr_m = (op->addr.nbytes && op->addr.buswidth > 1);
+	bool data_m = (op->data.nbytes && op->data.buswidth > 1);
+
+	if (!cmd_m && !addr_m && !data_m)
+		return DW_SPI_G2_TRANS_TYPE_TT0;	/* 1-1-1 */
+	if (!cmd_m && !addr_m && data_m)
+		return DW_SPI_G2_TRANS_TYPE_TT1;	/* 1-1-x */
+	if (!cmd_m && addr_m && data_m)
+		return DW_SPI_G2_TRANS_TYPE_TT2;	/* 1-x-x */
+
+	return -EOPNOTSUPP;
+}
+
+/**
+ * dw_spi_g2_is_reg_op - Check if operation is a register read/write
+ * @op: SPI memory operation
+ *
+ * Register operations are single-byte commands with no address (e.g.,
+ * RDSR, WRSR, RDID). Data must fit within the fixed-size stack buffer.
+ */
+static inline bool dw_spi_g2_is_reg_op(const struct spi_mem_op *op)
+{
+	return !op->addr.nbytes && op->data.nbytes > 0 &&
+	       op->data.nbytes <= DW_SPI_G2_REG_OP_MAX_DATA;
+}
+
+/**
+ * dw_spi_g2_xfer_fifo - Low-level FIFO transfer using polling
+ * @dws: Driver state
+ * @tx_buf: TX buffer (or NULL if no TX)
+ * @tx_len: Number of bytes to transmit
+ * @rx_buf: RX buffer (or NULL if no RX expected)
+ * @rx_len: Number of bytes to receive
+ *
+ * Performs a polled FIFO transfer. Writes tx_len bytes from tx_buf to DR0,
+ * checking SR.TFNF (TX FIFO not full) before each write. For RX, waits for
+ * RXFLR to indicate data availability, then reads rx_len bytes from DR0.
+ *
+ * Return: 0 on success, -ETIMEDOUT on timeout
+ */
+static int dw_spi_g2_xfer_fifo(struct dw_spi_g2 *dws,
+			       const u8 *tx_buf, u32 tx_len,
+			       u8 *rx_buf, u32 rx_len)
+{
+	u32 tx_sent = 0;
+	u32 rx_got = 0;
+	u32 sr;
+	unsigned long timeout;
+
+	/* TX phase: push bytes checking TFNF */
+	timeout = jiffies + msecs_to_jiffies(1000);
+	while (tx_sent < tx_len) {
+		sr = dw_spi_g2_readl(dws->regs, DW_SPI_G2_SR);
+		if (sr & DW_SPI_G2_SR_TFNF) {
+			dw_spi_g2_writel(dws->regs, DW_SPI_G2_DR0,
+					 tx_buf[tx_sent]);
+			tx_sent++;
+			timeout = jiffies + msecs_to_jiffies(1000);
+		} else if (time_after(jiffies, timeout)) {
+			dev_err(dws->dev,
+				"xfer_fifo: TX timeout after %u/%u bytes (SR=0x%08x)\n",
+				tx_sent, tx_len, sr);
+			return -ETIMEDOUT;
+		}
+		cpu_relax();
+	}
+
+	if (!rx_buf || !rx_len) {
+		dw_spi_g2_wait_idle(dws);
+		return 0;
+	}
+
+	/* RX phase */
+	timeout = jiffies + msecs_to_jiffies(1000);
+	while (rx_got < rx_len) {
+		sr = dw_spi_g2_readl(dws->regs, DW_SPI_G2_SR);
+		if (sr & DW_SPI_G2_SR_RFNE) {
+			rx_buf[rx_got++] = dw_spi_g2_readl(dws->regs,
+							   DW_SPI_G2_DR0) &
+			    0xff;
+			timeout = jiffies + msecs_to_jiffies(1000);
+		} else if (time_after(jiffies, timeout)) {
+			dev_err(dws->dev,
+				"xfer_fifo: RX timeout after %u/%u bytes (SR=0x%08x RXFLR=%u)\n",
+				rx_got, rx_len,
+				dw_spi_g2_readl(dws->regs, DW_SPI_G2_SR),
+				dw_spi_g2_readl(dws->regs, DW_SPI_G2_RXFLR));
+			return -ETIMEDOUT;
+		}
+		cpu_relax();
+	}
+
+	dw_spi_g2_wait_idle(dws);
+	return 0;
+}
+
+/**
+ * dw_spi_g2_fill_tx_buf - Serialize command/address/data into TX buffer
+ * @buf: Destination buffer
+ * @op: SPI memory operation
+ * @include_data: true to include data bytes, false for command+address only
+ *
+ * Builds a byte stream from a spi_mem_op structure:
+ *   [opcode bytes MSB..LSB] [address bytes MSB..LSB] [data bytes (optional)].
+ *
+ * Return: Total number of bytes written to buf
+ */
+static u32 dw_spi_g2_fill_tx_buf(u8 *buf, const struct spi_mem_op *op,
+				 bool include_data)
+{
+	u32 pos = 0;
+
+	/* Serialize multi-byte opcode (MSB first) */
+	for (u32 i = 0; i < op->cmd.nbytes; i++)
+		buf[pos++] =
+		    (op->cmd.opcode >> (8 * (op->cmd.nbytes - 1 - i))) & 0xff;
+
+	/* Serialize address (MSB first) */
+	for (u32 i = 0; i < op->addr.nbytes; i++)
+		buf[pos++] =
+		    (op->addr.val >> (8 * (op->addr.nbytes - 1 - i))) & 0xff;
+
+	/* Optionally append data bytes for write operations */
+	if (include_data && op->data.nbytes && op->data.dir == SPI_MEM_DATA_OUT) {
+		memcpy(&buf[pos], op->data.buf.out, op->data.nbytes);
+		pos += op->data.nbytes;
+	}
+
+	return pos;
+}
+
+/**
+ * Command-only operations (WREN, WRDI, Chip Erase, Sector Erase, etc.)
+ * TMOD=1 (TX-Only) — Send opcode + optional address, no data phase
+ */
+
+/**
+ * dw_spi_g2_cmd_only_setup - Configure controller for command-only operation
+ * @dws: Driver state
+ * @op: SPI memory operation
+ *
+ * Configures TMOD=TO (transmit-only), standard SPI mode..
+ */
+static void dw_spi_g2_cmd_only_setup(struct dw_spi_g2 *dws,
+				     const struct spi_mem_op *op)
+{
+	u32 ctrlr0 = dw_spi_g2_build_ctrlr0(dws, DW_SPI_G2_CTRLR0_TMOD_TO,
+					    DW_SPI_G2_FRF_STANDARD);
+
+	dw_spi_g2_controller_reset(dws);
+	dw_spi_g2_target_disable(dws, dws->cs);
+
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_CTRLR0(dws->cs), ctrlr0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_CTRLR1(dws->cs), 0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SPI_CTRLR0(dws->cs), 0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_TXFTLR, 0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_RXFTLR, 0);
+}
+
+/**
+ * dw_spi_g2_cmd_only - Execute command-only operation
+ * @dws: Driver state
+ * @op: SPI memory operation
+ *
+ * Sends a command with optional address but no data payload.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int dw_spi_g2_cmd_only(struct dw_spi_g2 *dws,
+			      const struct spi_mem_op *op)
+{
+	u8 buf[8];
+	u32 len;
+	int ret;
+
+	dw_spi_g2_cmd_only_setup(dws, op);
+
+	len = dw_spi_g2_fill_tx_buf(buf, op, false);
+
+	dw_spi_g2_transfer_begin(dws);
+	ret = dw_spi_g2_xfer_fifo(dws, buf, len, NULL, 0);
+	dw_spi_g2_transfer_end(dws);
+	dw_spi_g2_controller_reset(dws);
+	return ret;
+}
+
+static void dw_spi_g2_reg_op_setup(struct dw_spi_g2 *dws,
+				   const struct spi_mem_op *op)
+{
+	u8 tmod;
+	u32 ctrlr0;
+
+	dw_spi_g2_controller_reset(dws);
+	dw_spi_g2_target_disable(dws, dws->cs);
+
+	if (op->data.dir == SPI_MEM_DATA_IN) {
+		tmod = DW_SPI_G2_CTRLR0_TMOD_TR;
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_CTRLR1(dws->cs), 0);
+	} else {
+		tmod = DW_SPI_G2_CTRLR0_TMOD_TO;
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_CTRLR1(dws->cs), 0);
+	}
+
+	ctrlr0 = dw_spi_g2_build_ctrlr0(dws, tmod, DW_SPI_G2_FRF_STANDARD);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_CTRLR0(dws->cs), ctrlr0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SPI_CTRLR0(dws->cs), 0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_TXFTLR, 0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_RXFTLR, 0);
+}
+
+static int dw_spi_g2_reg_op(struct dw_spi_g2 *dws, const struct spi_mem_op *op)
+{
+	u8 tx_buf[DW_SPI_G2_REG_OP_MAX_DATA + 1];
+	u32 tx_len;
+	int ret;
+
+	/* Validate data length fits in stack buffer */
+	if (op->data.nbytes > DW_SPI_G2_REG_OP_MAX_DATA) {
+		dev_err(dws->dev, "reg_op data length %u exceeds max %u\n",
+			op->data.nbytes, DW_SPI_G2_REG_OP_MAX_DATA);
+		return -EINVAL;
+	}
+
+	dw_spi_g2_reg_op_setup(dws, op);
+
+	dw_spi_g2_transfer_begin(dws);
+
+	if (op->data.dir == SPI_MEM_DATA_OUT) {
+		if (!op->data.buf.out) {
+			dev_err(dws->dev, "TX buffer is NULL\n");
+			return -EINVAL;
+		}
+		/* TX: [opcode] [data bytes] */
+		tx_buf[0] = op->cmd.opcode;
+		memcpy(&tx_buf[1], op->data.buf.out, op->data.nbytes);
+		tx_len = 1 + op->data.nbytes;
+		ret = dw_spi_g2_xfer_fifo(dws, tx_buf, tx_len, NULL, 0);
+	} else {
+		if (!op->data.buf.in) {
+			dev_err(dws->dev, "RX buffer is NULL\n");
+			return -EINVAL;
+		}
+		/*
+		 * TR mode: each TX byte produces one RX byte.
+		 * Push opcode + nbytes dummy 0x00s, receive 1+nbytes,
+		 * discard first RX byte (echo of opcode phase).
+		 */
+		u8 rx_tmp[DW_SPI_G2_REG_OP_MAX_DATA + 1];
+
+		tx_buf[0] = op->cmd.opcode;
+		memset(&tx_buf[1], 0x00, op->data.nbytes);
+		tx_len = 1 + op->data.nbytes;
+		ret = dw_spi_g2_xfer_fifo(dws, tx_buf, tx_len, rx_tmp, tx_len);
+		if (!ret)
+			memcpy(op->data.buf.in, &rx_tmp[1], op->data.nbytes);
+	}
+
+	dw_spi_g2_transfer_end(dws);
+	dw_spi_g2_controller_reset(dws);
+
+	return ret;
+}
+
+/**
+ * Indirect read operations
+ */
+
+/*
+ * ========================================================================
+ * SPI-MEM interface
+ * ========================================================================
+ */
+
+static bool dw_spi_g2_supports_mem_ops(struct spi_mem *mem,
+				       const struct spi_mem_op *op)
+{
+	return spi_mem_default_supports_op(mem, op);
+}
+
+int dw_spi_g2_adjust_mem_op_size(struct spi_mem *mem, struct spi_mem_op *op)
+{
+	if (op->data.dir == SPI_MEM_DATA_IN)
+		op->data.nbytes = min_t(u32, op->data.nbytes, DW_G2_MAX_CHUNK);
+	else if (op->data.dir == SPI_MEM_DATA_OUT)
+		op->data.nbytes = min_t(u32, op->data.nbytes, DW_G2_MAX_CHUNK);
+
+	return 0;
+}
+
+static int dw_spi_g2_exec_mem_op(struct spi_mem *mem,
+				 const struct spi_mem_op *op)
+{
+	struct spi_device *spi = mem->spi;
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(spi->controller);
+
+	/* Validate operation structure */
+	if (!op || !op->cmd.nbytes) {
+		dev_err(dws->dev, "Invalid operation: missing command\n");
+		return -EINVAL;
+	}
+
+	/* Validate command length */
+	if (op->cmd.nbytes > 2) {
+		dev_err(dws->dev, "command length %u exceeds maximum 2 bytes\n",
+			op->cmd.nbytes);
+		return -EINVAL;
+	}
+
+	/* Validate address length */
+	if (op->addr.nbytes &&
+	    op->addr.nbytes * 8U > DW_SPI_G2_ADDR_L_MAX_BITS) {
+		dev_err(dws->dev, "address length %u bytes (%u bits) exceeds max %u bits\n",
+			op->addr.nbytes, op->addr.nbytes * 8U, DW_SPI_G2_ADDR_L_MAX_BITS);
+		return -EINVAL;
+	}
+
+	/* Validate dummy cycles */
+	if (op->dummy.nbytes) {
+		u32 dummy_cycles;
+
+		if (!op->dummy.buswidth || op->dummy.buswidth > 8) {
+			dev_err(dws->dev, "invalid dummy buswidth %u\n",
+				op->dummy.buswidth);
+			return -EINVAL;
+		}
+		dummy_cycles = (op->dummy.nbytes * 8) / op->dummy.buswidth;
+		if (dummy_cycles > DW_SPI_G2_SPI_CTRLR0_WAIT_CYCLES_MAX) {
+			dev_err(dws->dev, "dummy cycles %u exceed maximum %u\n",
+				dummy_cycles, DW_SPI_G2_SPI_CTRLR0_WAIT_CYCLES_MAX);
+			return -EINVAL;
+		}
+	}
+
+	/* Validate data length against controller limits */
+	if (op->data.nbytes > DW_G2_MAX_CHUNK) {
+		dev_err(dws->dev, "data length %u exceeds maximum %u\n",
+			op->data.nbytes, DW_G2_MAX_CHUNK);
+		return -EINVAL;
+	}
+
+	/* Get primary chip select (index 0 = first CS of this device) */
+	dws->cs = spi_get_chipselect(spi, 0);
+	dws->curr_spi = spi;
+
+	dev_dbg(dws->dev,
+		"exec_mem_op: cmd=0x%02x addr_len=%u data_len=%u dir=%d\n",
+		op->cmd.opcode, op->addr.nbytes, op->data.nbytes,
+		op->data.dir);
+
+	if (op->data.dir == SPI_MEM_NO_DATA)
+		return dw_spi_g2_cmd_only(dws, op);
+
+	if (dw_spi_g2_is_reg_op(op))
+		return dw_spi_g2_reg_op(dws, op);
+
+	/*
+	 * Bulk reads and writes are added by the indirect-transfer patch.
+	 * This patch handles commands and short register operations only.
+	 */
+	if (op->data.dir != SPI_MEM_NO_DATA && !dw_spi_g2_is_reg_op(op))
+		return -EOPNOTSUPP;
+
+	return -EOPNOTSUPP;
+}
+
+static const struct spi_controller_mem_ops dw_spi_g2_mem_ops = {
+	.supports_op = dw_spi_g2_supports_mem_ops,
+	.adjust_op_size = dw_spi_g2_adjust_mem_op_size,
+	.exec_op = dw_spi_g2_exec_mem_op,
+};
+
+/*
+ * FIFO depth is a synthesis-time parameter not exposed by any
+ * discoverable register and varies per instantiation (e.g. 256 on
+ * TDA54, 32 on the AM72 VDK). TXFTLR's field is only log2(fifo_depth)
+ * bits wide, so writing increasing values and reading back finds where
+ * the hardware clamps it - same probe spi-dw-core.c uses for this IP.
+ * Caller must have the controller disabled (SSIENR=0).
+ */
+static u32 dw_spi_g2_detect_fifo_len(struct dw_spi_g2 *dws)
+{
+	u32 fifo;
+
+	for (fifo = 1; fifo < DW_SPI_G2_FIFO_LEN; fifo++) {
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_TXFTLR, fifo);
+		if (dw_spi_g2_readl(dws->regs, DW_SPI_G2_TXFTLR) != fifo)
+			break;
+	}
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_TXFTLR, 0);
+
+	return (fifo == 1) ? DW_SPI_G2_FIFO_LEN : fifo;
+}
+
+/**
+ * dw_spi_g2_init - Initialize the SPI controller
+ * @dws: Driver state
+ *
+ * Performs one-time controller initialization:
+ *   - Disables SSI and clears chip selects
+ *   - Masks all interrupts (driver uses polling only)
+ *   - Sets FIFO depth and mode bits
+ *   - Registers spi-mem operations
+ *   - Creates debugfs entries
+ *
+ * Called once during probe. The controller is left in a disabled state;
+ * individual transfers will enable it as needed.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+int dw_spi_g2_init(struct dw_spi_g2 *dws)
+{
+	struct spi_controller *ctlr = dws->ctlr;
+
+	dev_info(dws->dev, "DW SSI G2 core init\n");
+
+	/* Disable controller and reset to clean state */
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SER, 0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_DEDICATED_CS_EN, 0);
+
+	/* Mask all interrupts — this driver uses polling only */
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_IMR, 0);
+	/* Clear all interrupts by writing 1s to defined ICR bits */
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_ICR, DW_SPI_G2_ICR_ALL);
+
+	/* Hardware capabilities */
+	dws->fifo_len = dw_spi_g2_detect_fifo_len(dws);
+	dws->caps = 0;
+
+	if (!dws->max_freq)
+		dws->max_freq = DW_SPI_G2_DEF_MAX_FREQ;
+
+	/* supported SPI modes to the framework */
+	ctlr->mode_bits = SPI_CPOL | SPI_CPHA |
+	    SPI_TX_DUAL | SPI_RX_DUAL |
+	    SPI_TX_QUAD | SPI_RX_QUAD | SPI_TX_OCTAL | SPI_RX_OCTAL;
+
+	ctlr->bits_per_word_mask = SPI_BPW_MASK(8);
+	ctlr->flags = 0;
+
+	ctlr->setup = dw_spi_g2_setup;
+	ctlr->mem_ops = &dw_spi_g2_mem_ops;
+
+	dw_spi_g2_debugfs_init(dws);
+	init_completion(&dws->mem_done);
+
+	dev_info(dws->dev, "Core Init done: fifo=%u max_freq=%u\n",
+		 dws->fifo_len, dws->max_freq);
+
+	return 0;
+}
+EXPORT_SYMBOL_NS_GPL(dw_spi_g2_init, "SPI_DW_G2_CORE");
+
+/**
+ * dw_spi_g2_deinit - Clean up controller resources
+ * @dws: Driver state
+ *
+ * Called during driver removal to clean up debugfs and other resources.
+ */
+void dw_spi_g2_deinit(struct dw_spi_g2 *dws)
+{
+	dw_spi_g2_debugfs_remove(dws);
+}
+EXPORT_SYMBOL_NS_GPL(dw_spi_g2_deinit, "SPI_DW_G2_CORE");
+
+/*
+ * ========================================================================
+ * Legacy SPI transfer_one interface (not actively used with spi-mem)
+ * ========================================================================
+ */
+
+/**
+ * dw_spi_g2_update_config - Update controller configuration for a transfer
+ * @dws: Driver state
+ * @spi: SPI device
+ * @cfg: Transfer configuration
+ *
+ * Programs CTRLR0, CTRLR1, and BAUDR for a transfer. Used by the legacy
+ * transfer_one path (not used when operating via spi-mem).
+ */
+void dw_spi_g2_update_config(struct dw_spi_g2 *dws, struct spi_device *spi,
+			     struct dw_spi_g2_cfg *cfg)
+{
+	u32 ctrlr0 = 0;
+	u32 div;
+
+	ctrlr0 |= FIELD_PREP(DW_SPI_G2_CTRLR0_DFS_MASK, cfg->dfs - 1);
+	ctrlr0 |= FIELD_PREP(DW_SPI_G2_CTRLR0_TMOD_MASK, cfg->tmode);
+
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_CTRLR0(dws->cs), ctrlr0);
+
+	if (cfg->tmode == DW_SPI_G2_CTRLR0_TMOD_RO)
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_CTRLR1(dws->cs), cfg->ndf - 1);
+
+	div = DIV_ROUND_UP(dws->max_freq, cfg->freq);
+	if (div & 1)
+		div++;
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_BAUDR(dws->cs), div);
+}
+
+/**
+ * dw_spi_g2_transfer_one - Execute a single SPI transfer (legacy interface)
+ * @ctlr: SPI controller
+ * @spi: SPI device
+ * @xfer: Transfer to execute
+ *
+ * Implements the legacy transfer_one callback for the SPI framework.
+ * This path is NOT used when the controller operates via spi-mem
+ * (which is the primary mode for flash operations). Provided for
+ * compatibility with non-memory SPI devices.
+ *
+ * Uses polling-based full-duplex (TMOD=TR) transfers.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+int dw_spi_g2_transfer_one(struct spi_controller *ctlr, struct spi_device *spi,
+			   struct spi_transfer *xfer)
+{
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(ctlr);
+	struct dw_spi_g2_cfg cfg = {
+		.tmode = DW_SPI_G2_CTRLR0_TMOD_TR,
+		.dfs = xfer->bits_per_word,
+		.freq = xfer->speed_hz,
+	};
+	u32 sr;
+
+	dws->tx = xfer->tx_buf;
+	dws->rx = xfer->rx_buf;
+	dws->tx_len = xfer->len;
+	dws->rx_len = xfer->len;
+	dws->n_bytes = 1;
+
+	/* Ensure writes to device reach memory before enable */
+	wmb();
+
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_update_config(dws, spi, &cfg);
+
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_TXFTLR, dws->fifo_len / 2);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_RXFTLR, (dws->fifo_len / 2) - 1);
+
+	dw_spi_g2_enable(dws, true);
+
+	local_irq_disable();
+	/* Polling-based full-duplex transfer */
+	while (dws->tx_len || dws->rx_len) {
+		sr = dw_spi_g2_readl(dws->regs, DW_SPI_G2_SR);
+
+		/* Transmit if FIFO not full and bytes remaining */
+		if (dws->tx_len && (sr & DW_SPI_G2_SR_TFNF)) {
+			u8 val = 0;
+
+			if (dws->tx) {
+				val = *(u8 *)dws->tx;
+				dws->tx += 1;
+			}
+			dw_spi_g2_writel(dws->regs, DW_SPI_G2_DR0, val);
+			dws->tx_len--;
+		}
+
+		/* Receive if FIFO not empty and bytes expected */
+		if (dws->rx_len && (sr & DW_SPI_G2_SR_RFNE)) {
+			u8 val = dw_spi_g2_readl(dws->regs, DW_SPI_G2_DR0);
+
+			if (dws->rx) {
+				*(u8 *)dws->rx = val;
+				dws->rx += 1;
+			}
+			dws->rx_len--;
+		}
+		cpu_relax();
+	}
+	local_irq_enable();
+
+	/* Wait for transfer completion */
+	if (dw_spi_g2_wait_idle(dws)) {
+		dev_err(dws->dev, "transfer_one: timeout waiting for idle\n");
+		dw_spi_g2_enable(dws, false);
+		return -ETIMEDOUT;
+	}
+
+	dw_spi_g2_enable(dws, false);
+
+	spi_finalize_current_transfer(ctlr);
+	return 0;
+}
+
+/**
+ * dw_spi_g2_irq - Minimal interrupt handler for error detection
+ * @irq: IRQ number
+ * @dev_id: Driver state
+ *
+ * This driver operates in polling mode with all interrupts masked (IMR=0).
+ * This handler should normally not be invoked. It exists only to catch
+ * unexpected error interrupts that may occur despite masking.
+ *
+ * Return: IRQ_HANDLED if interrupt was ours, IRQ_NONE otherwise
+ */
+irqreturn_t dw_spi_g2_irq(int irq, void *dev_id)
+{
+	struct dw_spi_g2 *dws = dev_id;
+	u32 isr;
+
+	isr = dw_spi_g2_readl(dws->regs, DW_SPI_G2_ISR);
+	if (!isr)
+		return IRQ_NONE;
+
+	/* Check for error conditions */
+	if (isr & (DW_SPI_G2_ISR_RXOI | DW_SPI_G2_ISR_RXUI |
+		   DW_SPI_G2_ISR_TXOI | DW_SPI_G2_ISR_TXUI)) {
+		dev_warn(dws->dev, "Error interrupt: ISR=0x%x\n", isr);
+		dws->error = -EIO;
+	}
+
+	/* Clear all interrupts by writing 1s to defined ICR bits */
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_ICR, DW_SPI_G2_ICR_ALL);
+
+	return IRQ_HANDLED;
+}
+EXPORT_SYMBOL_NS_GPL(dw_spi_g2_irq, "SPI_DW_G2_CORE");
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("DesignWare SPI Gen2 SSI Controller");
diff --git a/drivers/spi/spi-dw-g2-mmio.c b/drivers/spi/spi-dw-g2-mmio.c
new file mode 100644
index 000000000000..6ef8f926e0eb
--- /dev/null
+++ b/drivers/spi/spi-dw-g2-mmio.c
@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: GPL-2.0-only OR MIT
+
+#include <linux/clk.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/reset.h>
+#include <linux/spi/spi.h>
+#include <linux/interrupt.h>
+
+#include "spi-dw-g2.h"
+
+struct dw_spi_g2_mmio {
+	struct dw_spi_g2	dws;
+	struct clk		*clk;
+	struct clk		*pclk;
+	struct reset_control	*rstc;
+};
+
+static int dw_spi_g2_mmio_probe(struct platform_device *pdev)
+{
+	struct dw_spi_g2_mmio *dwsmmio;
+	struct dw_spi_g2 *dws;
+	struct resource *mem;
+	struct spi_controller *ctlr;
+	u32 num_cs;
+	int ret;
+
+	ctlr = spi_alloc_host(&pdev->dev, sizeof(*dwsmmio));
+	if (!ctlr)
+		return -ENOMEM;
+
+	platform_set_drvdata(pdev, ctlr);
+
+	dwsmmio = spi_controller_get_devdata(ctlr);
+	dws = &dwsmmio->dws;
+
+	dws->dev = &pdev->dev;
+	dws->ctlr = ctlr;
+
+	/* MMIO */
+	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	dws->regs = devm_ioremap_resource(&pdev->dev, mem);
+	if (IS_ERR(dws->regs)) {
+		ret = PTR_ERR(dws->regs);
+		goto err_put;
+	}
+
+	/*
+	 * IRQ.
+	 *
+	 * The DWC SSI Gen2 IP exposes per-source interrupt outputs
+	 * alongside a combined ssi_intr. SoC integrators may route
+	 * either the combined line, the individual lines, or any
+	 * subset. We accept both DT forms:
+	 *
+	 *  - Named-line DT: one entry per output, with interrupt-names
+	 *    in {"rxf","txe","txaf","wsf"}. Each line is requested
+	 *    and bound to the shared dw_spi_g2_irq() decoder.
+	 *  - Single-line DT: combined ssi_intr at index 0, used by
+	 *    integrations that OR the sources in HW.
+	 *
+	 * Either way dws->irq holds the "primary" line (rxf when
+	 * named, index 0 otherwise) so debugfs and PM paths stay
+	 * source-agnostic.
+	 */
+	dws->irq = platform_get_irq_byname_optional(pdev, "rxf");
+	if (dws->irq < 0)
+		dws->irq = platform_get_irq(pdev, 0);
+	if (dws->irq < 0) {
+		ret = dws->irq;
+		goto err_put;
+	}
+
+	/* clocks */
+	dwsmmio->clk = devm_clk_get_enabled(&pdev->dev, NULL);
+	if (IS_ERR(dwsmmio->clk)) {
+		ret = PTR_ERR(dwsmmio->clk);
+		goto err_put;
+	}
+
+	dwsmmio->pclk = devm_clk_get_optional_enabled(&pdev->dev, "pclk");
+	if (IS_ERR(dwsmmio->pclk)) {
+		ret = PTR_ERR(dwsmmio->pclk);
+		goto err_put;
+	}
+
+	dws->clk_rate = clk_get_rate(dwsmmio->clk);
+	dev_dbg(&pdev->dev, "SSI clock rate = %u Hz\n", dws->clk_rate);
+
+	/* Reset control (shared: multiple IPs may use same reset line) */
+	dwsmmio->rstc = devm_reset_control_get_optional_shared(&pdev->dev, NULL);
+	if (IS_ERR(dwsmmio->rstc)) {
+		ret = PTR_ERR(dwsmmio->rstc);
+		goto err_put;
+	}
+
+	reset_control_deassert(dwsmmio->rstc);
+
+	/* Read num-cs from device tree */
+	ret = device_property_read_u32(&pdev->dev, "num-cs", &num_cs);
+	if (ret) {
+		dev_err(&pdev->dev, "Failed to read 'num-cs' property: %d\n", ret);
+		goto err_reset;
+	}
+	ctlr->num_chipselect = num_cs;
+
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SER, 0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_DEDICATED_CS_EN,
+			 GENMASK(ctlr->num_chipselect - 1, 0));
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_IMR, 0);
+	/* Clear all interrupts by writing 1s to defined ICR bits */
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_ICR, DW_SPI_G2_ICR_ALL);
+
+	/*
+	 * Latch the static controller identity once. VERSION_ID and
+	 * HW_CAPABILITIES are read-only and never change at runtime.
+	 */
+	dws->version_id = dw_spi_g2_readl(dws->regs, DW_SPI_G2_VERSION_ID);
+	dws->hw_caps = dw_spi_g2_readl(dws->regs, DW_SPI_G2_HW_CAPABILITIES);
+	dws->caps = dws->hw_caps;
+
+	dev_dbg(dws->dev, "VERSION_ID = 0x%08x\n", dws->version_id);
+	dev_dbg(dws->dev, "HW_CAPS = 0x%08x\n", dws->hw_caps);
+
+	dws->max_freq = clk_get_rate(dwsmmio->clk);
+	/* SPI Controller Setup */
+	ctlr->bus_num = of_alias_get_id(pdev->dev.of_node, "spi");
+	if (ctlr->bus_num < 0)
+		ctlr->bus_num = pdev->id;
+	ctlr->transfer_one = NULL;
+	ctlr->dev.of_node = pdev->dev.of_node;
+
+	spi_controller_set_devdata(ctlr, dws);
+
+	/* core init */
+	ret = dw_spi_g2_init(dws);
+	if (ret)
+		goto err_reset;
+
+	ret = devm_request_irq(&pdev->dev, dws->irq, dw_spi_g2_irq, 0,
+			       dev_name(&pdev->dev), dws);
+	if (ret)
+		goto err_reset;
+
+	pm_runtime_enable(&pdev->dev);
+
+	ret = spi_register_controller(ctlr);
+	if (ret)
+		goto err_pm;
+
+	dev_info(&pdev->dev, "DW SSI G2 MMIO probed\n");
+	return 0;
+
+err_pm:
+	pm_runtime_disable(&pdev->dev);
+err_reset:
+	reset_control_assert(dwsmmio->rstc);
+err_put:
+	spi_controller_put(ctlr);
+	return ret;
+}
+
+static void dw_spi_g2_mmio_remove(struct platform_device *pdev)
+{
+	struct spi_controller *ctlr = platform_get_drvdata(pdev);
+	struct dw_spi_g2_mmio *dwsmmio = spi_controller_get_devdata(ctlr);
+
+	spi_unregister_controller(ctlr);
+	dw_spi_g2_deinit(&dwsmmio->dws);
+	pm_runtime_disable(&pdev->dev);
+	reset_control_assert(dwsmmio->rstc);
+}
+
+static const struct of_device_id dw_spi_g2_of_match[] = {
+	{ .compatible = "snps,dwc-ssi-2.02a", .data = dw_spi_g2_init},
+	{ }
+};
+MODULE_DEVICE_TABLE(of, dw_spi_g2_of_match);
+
+static struct platform_driver dw_spi_g2_mmio_driver = {
+	.probe  = dw_spi_g2_mmio_probe,
+	.remove = dw_spi_g2_mmio_remove,
+	.driver = {
+		.name = "dw-spi-g2-mmio",
+		.of_match_table = dw_spi_g2_of_match,
+	},
+};
+
+module_platform_driver(dw_spi_g2_mmio_driver);
+
+MODULE_IMPORT_NS("SPI_DW_G2_CORE");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("DesignWare SSI G2 MMIO driver");
diff --git a/drivers/spi/spi-dw-g2.h b/drivers/spi/spi-dw-g2.h
new file mode 100644
index 000000000000..1106be0af7b6
--- /dev/null
+++ b/drivers/spi/spi-dw-g2.h
@@ -0,0 +1,396 @@
+/* SPDX-License-Identifier: GPL-2.0-only OR MIT */
+
+#ifndef _SPI_DW_G2_H
+#define _SPI_DW_G2_H
+
+#include <linux/spi/spi.h>
+#include <linux/io.h>
+#include <linux/device.h>
+#include <linux/irqreturn.h>
+#include <linux/iopoll.h>
+#include <linux/spi/spi-mem.h>
+
+#ifdef CONFIG_DEBUG_FS
+#include <linux/debugfs.h>
+#endif
+
+/* Identification */
+#define DW_SPI_G2_REG_MAP_VERSION       0x00
+#define DW_SPI_G2_HW_CAPABILITIES       0x04
+#define DW_SPI_G2_VERSION_ID            0x8C
+
+/* Dedicated CS Offset */
+#define DW_SPI_G2_DEDICATED_CS_BASE             0x1AC
+#define DW_SPI_G2_DEDICATED_CS_STRIDE           0x14
+#define DW_SPI_G2_DEDICATED_CS_EN               0x50
+#define DW_SPI_G2_CS_OFFSET(cs) \
+		(DW_SPI_G2_DEDICATED_CS_BASE + (cs) * DW_SPI_G2_DEDICATED_CS_STRIDE)
+
+/* Dedicated CS Blocks */
+#define DW_SPI_G2_CTRLR0(cs)            (DW_SPI_G2_CS_OFFSET(cs) + 0x04)
+#define DW_SPI_G2_SPI_CTRLR0(cs)        (DW_SPI_G2_CS_OFFSET(cs) + 0x08)
+#define DW_SPI_G2_BAUDR(cs)             (DW_SPI_G2_CS_OFFSET(cs) + 0x0C)
+#define DW_SPI_G2_CTRLR1(cs)            (DW_SPI_G2_CS_OFFSET(cs) + 0x10)
+#define DW_SPI_G2_SPI_CTRLR1(cs)        (DW_SPI_G2_CS_OFFSET(cs) + 0x14)
+
+#define DW_SPI_G2_SSIENR                0x4C
+#define DW_SPI_G2_SER                   0x54
+#define DW_SPI_G2_TXFTLR                0x58
+#define DW_SPI_G2_RXFTLR                0x5c
+#define DW_SPI_G2_TXFLR                 0x60
+#define DW_SPI_G2_RXFLR                 0x64
+#define DW_SPI_G2_SR                    0x6C
+#define DW_SPI_G2_DR0                   0x90
+#define DW_SPI_G2_DR1                   0x94
+#define DW_SPI_G2_DR(i)                 (DW_SPI_G2_DR0 + ((i) * 4))
+#define DW_SPI_G2_IMR                   0x70
+#define DW_SPI_G2_ISR                   0x74
+#define DW_SPI_G2_RISR                  0x78
+#define DW_SPI_G2_ICR                   0x7C
+#define DW_SPI_G2_IDR                   0x88
+
+/* ISR bit masks (interrupt status) */
+#define DW_SPI_G2_ISR_TXEI              BIT(0)  /* TX FIFO Empty */
+#define DW_SPI_G2_ISR_TXOI              BIT(1)  /* TX FIFO Overflow */
+#define DW_SPI_G2_ISR_RXUI              BIT(2)  /* RX FIFO Underflow */
+#define DW_SPI_G2_ISR_RXOI              BIT(3)  /* RX FIFO Overflow */
+#define DW_SPI_G2_ISR_RXFI              BIT(4)  /* RX FIFO Full */
+#define DW_SPI_G2_ISR_MSTI              BIT(5)  /* Multi-Master Error */
+#define DW_SPI_G2_ISR_XRXOI             BIT(6)  /* Extended RX Overflow */
+#define DW_SPI_G2_ISR_TXUI              BIT(7)  /* TX FIFO Underflow */
+
+/* ICR bit masks (write 1 to clear corresponding interrupt) */
+#define DW_SPI_G2_ICR_TXOICR            BIT(1)  /* TX FIFO Overflow Clear */
+#define DW_SPI_G2_ICR_RXUICR            BIT(2)  /* RX FIFO Underflow Clear */
+#define DW_SPI_G2_ICR_RXOICR            BIT(3)  /* RX FIFO Overflow Clear */
+#define DW_SPI_G2_ICR_MSTICR            BIT(5)  /* Multi-Master Clear */
+#define DW_SPI_G2_ICR_XRXOICR           BIT(6)  /* Extended RX Overflow Clear */
+#define DW_SPI_G2_ICR_TXUICR            BIT(7)  /* TX FIFO Underflow Clear */
+#define DW_SPI_G2_ICR_AXIEICR           BIT(8)  /* AXI Error Clear */
+#define DW_SPI_G2_ICR_SPITEICR          BIT(10) /* SPI Transmit Error Clear */
+#define DW_SPI_G2_ICR_DONEICR           BIT(11) /* SSI Done Clear */
+#define DW_SPI_G2_ICR_SPIWSFICR         BIT(13) /* SPI Write Status Fail Clear */
+#define DW_SPI_G2_ICR_ECCCEICR          BIT(15) /* ECC Correctable Error Clear */
+#define DW_SPI_G2_ICR_ECCUCEICR         BIT(16) /* ECC Uncorrectable Error Clear */
+#define DW_SPI_G2_ICR_PVTTICR           BIT(17) /* PVT Tracking Interrupt Clear */
+/* Clear all writable bits */
+#define DW_SPI_G2_ICR_ALL               0x0003AFFF
+
+#define DW_SPI_G2_RX_SAMPLE_DELAY       0x24
+
+/* CTRLR0 fields */
+#define DW_SPI_G2_CTRLR0_DFS_MASK     GENMASK(4, 0)
+#define DW_SPI_G2_CTRLR0_FRF_MASK     GENMASK(15, 14)
+#define DW_SPI_G2_CTRLR0_TMOD_MASK    GENMASK(11, 10)
+#define DW_SPI_G2_CTRLR0_SCPHA        BIT(8)
+#define DW_SPI_G2_CTRLR0_SCPOL        BIT(9)
+#define DW_SPI_G2_CTRLR0_SRL          BIT(12)
+
+/* SPI_CTRLR0 fields */
+#define DW_SPI_G2_SPI_CTRLR0_TRANS_TYPE_SHIFT        0
+#define DW_SPI_G2_SPI_CTRLR0_TRANS_TYPE_MASK         GENMASK(1, 0)
+#define DW_SPI_G2_SPI_CTRLR0_ADDR_L_SHIFT            2
+#define DW_SPI_G2_SPI_CTRLR0_ADDR_L_MASK             GENMASK(5, 2)
+#define DW_SPI_G2_SPI_CTRLR0_INST_L_SHIFT            8
+#define DW_SPI_G2_SPI_CTRLR0_INST_L_MASK             GENMASK(9, 8)
+#define DW_SPI_G2_SPI_CTRLR0_WAIT_CYCLE_SHIFT        11
+#define DW_SPI_G2_SPI_CTRLR0_WAIT_CYCLE_MASK         GENMASK(15, 11)
+#define DW_SPI_G2_SPI_CTRLR0_WAIT_CYCLES_MAX         0x1FU
+#define DW_SPI_G2_SPI_CTRLR0_DDR_EN_MASK             BIT(16)
+#define DW_SPI_G2_SPI_CTRLR0_INST_DDR_EN_MASK        BIT(17)
+#define DW_SPI_G2_SPI_CTRLR0_INST_RXDS_EN_MASK       BIT(18)
+
+#define DW_SPI_G2_SPI_CTRLR0_ADDR_L_MAX			0xFU
+#define DW_SPI_G2_SPI_CTRLR0_ADDR_L_BITS_PER_STEP	4U
+#define DW_SPI_G2_ADDR_L_MAX_BITS \
+	((unsigned int)(DW_SPI_G2_SPI_CTRLR0_ADDR_L_MAX * \
+			DW_SPI_G2_SPI_CTRLR0_ADDR_L_BITS_PER_STEP))
+
+/* TMOD values */
+#define DW_SPI_G2_CTRLR0_TMOD_TR		0x0     /* xmit & recv */
+#define DW_SPI_G2_CTRLR0_TMOD_TO		0x1	/* xmit only */
+#define DW_SPI_G2_CTRLR0_TMOD_RO		0x2	/* recv only */
+#define DW_SPI_G2_CTRLR0_TMOD_EEPROMREAD	0x3	/* eeprom read mode */
+
+/* FRF */
+#define DW_SPI_G2_FRF_STANDARD              0x0
+#define DW_SPI_G2_FRF_DUAL                  0x1
+#define DW_SPI_G2_FRF_QUAD                  0x2
+#define DW_SPI_G2_FRF_OCTAL                 0x3
+
+/* Transfer Type */
+#define DW_SPI_G2_TRANS_TYPE_TT0                0x0
+#define DW_SPI_G2_TRANS_TYPE_TT1                0x1
+#define DW_SPI_G2_TRANS_TYPE_TT2                0x2
+#define DW_SPI_G2_TRANS_TYPE_TT3                0x3
+
+/* SR bits */
+#define DW_SPI_G2_SR_BUSY               BIT(0)
+#define DW_SPI_G2_SR_TFNF               BIT(1)
+#define DW_SPI_G2_SR_TFE                BIT(2)
+#define DW_SPI_G2_SR_RFNE               BIT(3)
+#define DW_SPI_G2_SR_RFF                BIT(4)
+#define DW_SPI_G2_SR_WIP                BIT(7)
+
+/* DFS encoding */
+#define DW_SPI_G2_DFS_8BIT              7U
+#define DW_SPI_G2_DFS_16BIT             15U
+#define DW_SPI_G2_DFS_32BIT             31U
+#define DW_SPI_G2_DFS_ENCODE(bits)      ((bits) - 1)
+
+/* INST_L encoding */
+#define DW_SPI_G2_INST_L_0              0x0
+#define DW_SPI_G2_INST_L_4              0x1
+#define DW_SPI_G2_INST_L_8              0x2
+#define DW_SPI_G2_INST_L_16             0x3
+
+static inline u32 dw_spi_g2_inst_len(unsigned int n)
+{
+	switch (n) {
+	case 0:
+		return DW_SPI_G2_INST_L_0;
+	case 1:
+		return DW_SPI_G2_INST_L_8;
+	case 2:
+		return DW_SPI_G2_INST_L_16;
+	default:
+		return DW_SPI_G2_INST_L_8;
+	}
+}
+
+/* ADDR_L encoding */
+#define DW_SPI_G2_ADDR_L_0              0x0
+#define DW_SPI_G2_ADDR_L_4              0x1
+#define DW_SPI_G2_ADDR_L_8              0x2
+#define DW_SPI_G2_ADDR_L_16             0x4
+#define DW_SPI_G2_ADDR_L_24             0x6
+#define DW_SPI_G2_ADDR_L_32             0x8
+
+/*
+ * Map @addr_nbytes to ADDR_L register encoding.
+ *
+ * ADDR_L encoding: Each increment = 4 bits. ADDR_L=n means n×4 bits.
+ *   ADDR_L=0 == 0 bits,  ADDR_L=2 == 8 bits (1 byte),  ADDR_L=4 == 16 bits (2 bytes), etc.
+ *
+ * Formula: ADDR_L = (addr_bits / 4) = (addr_nbytes × 8) / 4 = addr_nbytes × 2
+ *
+ * Note: This function assumes byte-aligned addresses (multiple of 8 bits), which
+ * matches the Linux spi-mem framework's addr.nbytes field. The hardware supports
+ * non-byte-aligned lengths (4, 12, 20 bits, etc.) via other ADDR_L values (1, 3, 5),
+ * but the spi-mem framework does not expose bit-level addressing.
+ *
+ * Caller must ensure addr_nbytes * 8 <= DW_SPI_G2_ADDR_L_MAX_BITS (60 bits).
+ */
+static inline u32 dw_spi_g2_addr_len(unsigned int addr_nbytes)
+{
+	return addr_nbytes ? addr_nbytes * 2U : 0U;
+}
+
+/*
+ * Maximum chunk size for indirect reads.
+ * 64KB allows efficient large transfers while staying well within typical
+ * controller limits. The FIFO (256 bytes) drains continuously during
+ * the transfer via polling.
+ */
+#define DW_G2_MAX_CHUNK		256U
+
+/* Timeout in microseconds for polling operations */
+#define DW_SPI_G2_TIMEOUT_US	200000U
+
+/* Default max frequency in Hz (100 MHz) */
+#define DW_SPI_G2_DEF_MAX_FREQ	100000000U
+
+/* Default FIFO depth */
+#define DW_SPI_G2_FIFO_LEN	256U
+
+/*
+ * Maximum baud rate divisor value for BAUDR register.
+ * BAUDR encoding: bit[0]=passthrough_en, bits[15:1]=SCKDV (divisor).
+ * Max SCKDV = 0x7FFF (32767), encoded as BAUDR = 0xFFFE (65534).
+ * Note: divisor must be even (BAUDR >= 2), except BAUDR=1 (passthrough).
+ */
+#define DW_SPI_G2_MAX_BAUDR	65534U
+
+/*
+ * Maximum data bytes for register operations (stack buffer size - 1 for opcode).
+ * Register ops use small stack buffers: tx_buf[16] and rx_tmp[16].
+ * Buffer layout: [opcode (1 byte)][data (up to 15 bytes)].
+ * This is sufficient for typical SPI NOR register commands:
+ *   - RDID: 3 bytes
+ *   - RDSR: 1-2 bytes
+ *   - RDFR: 1 byte
+ *   - etc.
+ * Larger transfers use indirect read/write with FIFO (up to DW_G2_MAX_CHUNK).
+ */
+#define DW_SPI_G2_REG_OP_MAX_DATA	15U
+
+struct dw_spi_g2_cfg {
+	u8 tmode;
+	u8 dfs;
+	u32 ndf;
+	u32 freq;
+};
+
+struct dw_spi_g2 {
+	struct device          *dev;
+	struct spi_controller  *ctlr;
+
+	void __iomem           *regs;
+	resource_size_t         paddr;
+	int                     irq;
+
+	u32                     cs;
+	u32                     fifo_len;
+	u32                     caps;
+	/* Static controller identity, read once at probe */
+	u32                     version_id;
+	u32                     hw_caps;
+	u32                     max_freq;
+	u32                     clk_rate;
+
+	/* Current message transfer state info */
+	const void		*tx;
+	unsigned int		tx_len;
+	void		        *rx;
+	unsigned int		rx_len;
+	u8			n_bytes;
+
+	struct spi_device       *curr_spi;
+	struct completion       mem_done;
+	int                     error;
+
+#ifdef CONFIG_DEBUG_FS
+	struct dentry *debugfs;
+	struct debugfs_regset32 regset;
+#endif
+};
+
+struct dw_spi_g2_memtrx {
+	u8              opcode;
+	u8              inst_len;
+	u32             addr;
+	u8              addr_len;
+	u8              dummy_cycles;
+	u32             data_len;
+	bool            is_read;
+	bool            is_write;
+	const u8        *tx;
+	u8              *rx;
+};
+
+/* Low-level register access */
+/*
+ * Use the barrier-embedding readl()/writel() accessors (not the *_relaxed
+ * variants) so every register access is ordered with respect to normal
+ * memory: writel()'s wmb drains prior stores before the MMIO write and
+ * readl()'s rmb completes the read before subsequent accesses. This
+ * guarantees, for example, that DR0 TX-FIFO fills reach the controller
+ * before the CS-asserting SER write triggers the transfer, without
+ * needing explicit wmb() barriers on the transfer paths.
+ */
+static inline u32 dw_spi_g2_readl(void __iomem *base, u32 off)
+{
+	return readl(base + off);
+}
+
+static inline void dw_spi_g2_writel(void __iomem *base, u32 off, u32 val)
+{
+	writel(val, base + off);
+}
+
+/* APIs */
+int dw_spi_g2_setup(struct spi_device *spi);
+
+int dw_spi_g2_init(struct dw_spi_g2 *dws);
+
+void dw_spi_g2_deinit(struct dw_spi_g2 *dws);
+
+void dw_spi_g2_update_config(struct dw_spi_g2 *dws, struct spi_device *spi,
+			     struct dw_spi_g2_cfg *cfg);
+
+int dw_spi_g2_transfer_one(struct spi_controller *ctlr, struct spi_device *spi,
+			   struct spi_transfer *xfer);
+
+int dw_spi_g2_adjust_mem_op_size(struct spi_mem *mem, struct spi_mem_op *op);
+
+irqreturn_t dw_spi_g2_irq(int irq, void *dev_id);
+
+/* Helpers */
+static inline void dw_spi_g2_enable(struct dw_spi_g2 *dws, bool en)
+{
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SSIENR, en ? 1 : 0);
+}
+
+static inline void dw_spi_g2_target_disable(struct dw_spi_g2 *dws, u32 cs)
+{
+	u32 reg_val = dw_spi_g2_readl(dws->regs, DW_SPI_G2_DEDICATED_CS_EN);
+
+	reg_val &= ~BIT(cs);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_DEDICATED_CS_EN, reg_val);
+}
+
+static inline void dw_spi_g2_target_enable(struct dw_spi_g2 *dws, u32 cs)
+{
+	u32 reg_val = dw_spi_g2_readl(dws->regs, DW_SPI_G2_DEDICATED_CS_EN);
+
+	reg_val |= BIT(cs);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_DEDICATED_CS_EN, reg_val);
+}
+
+static inline void dw_spi_g2_cs_assert(struct dw_spi_g2 *dws, u32 cs)
+{
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SER, BIT(cs));
+}
+
+static inline void dw_spi_g2_cs_deassert(struct dw_spi_g2 *dws, u32 cs)
+{
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SER, 0);
+}
+
+static inline int dw_spi_g2_wait_tfnf(struct dw_spi_g2 *dws)
+{
+	u32 sr;
+
+	return readl_poll_timeout(dws->regs + DW_SPI_G2_SR, sr,
+				  sr & DW_SPI_G2_SR_TFNF, 1, DW_SPI_G2_TIMEOUT_US);
+}
+
+static inline int dw_spi_g2_wait_rfne(struct dw_spi_g2 *dws)
+{
+	u32 sr;
+
+	return readl_poll_timeout(dws->regs + DW_SPI_G2_SR, sr,
+				  sr & DW_SPI_G2_SR_RFNE, 1, DW_SPI_G2_TIMEOUT_US);
+}
+
+static inline int dw_spi_g2_wait_idle(struct dw_spi_g2 *dws)
+{
+	u32 sr;
+
+	return readl_poll_timeout(dws->regs + DW_SPI_G2_SR, sr,
+				  !(sr & DW_SPI_G2_SR_BUSY), 1, DW_SPI_G2_TIMEOUT_US);
+}
+
+/*
+ * Transfer control: enable CS register block, assert CS line, enable SSI.
+ * Starts the SPI transfer — controller begins clocking data.
+ */
+static inline void dw_spi_g2_transfer_begin(struct dw_spi_g2 *dws)
+{
+	dw_spi_g2_target_enable(dws, dws->cs);
+	dw_spi_g2_cs_assert(dws, dws->cs);
+	dw_spi_g2_enable(dws, true);
+}
+
+/*
+ * Transfer control: disable SSI, deassert CS line, disable CS register block.
+ * Ends the SPI transfer and cleanly releases the bus.
+ */
+static inline void dw_spi_g2_transfer_end(struct dw_spi_g2 *dws)
+{
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_cs_deassert(dws, dws->cs);
+	dw_spi_g2_target_disable(dws, dws->cs);
+}
+
+#endif /* __SPI_DW_G2_H__ */
-- 
2.34.1


  parent reply	other threads:[~2026-11-19 10:06 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-19 10:05 [PATCH 0/6] spi: dw-g2: add Synopsys DWC SSI v2.02a controller support Prakriti Sharma
2026-11-19 10:05 ` [PATCH 1/6] dt-bindings: spi: Add Synopsys DWC SSI v2.02a binding Prakriti Sharma
2026-11-19 10:05 ` Prakriti Sharma [this message]
2026-11-19 10:05 ` [PATCH 3/6] spi: dw-g2: Add indirect read and write Prakriti Sharma
2026-11-19 10:05 ` [PATCH 4/6] spi: dw-g2: Add SPI-NAND support Prakriti Sharma
2026-11-19 10:05 ` [PATCH 5/6] dt-bindings: spi: Document DWC SSI XIP properties Prakriti Sharma
2026-11-19 12:18   ` Krzysztof Kozlowski
2026-11-19 10:05 ` [PATCH 6/6] spi: dw-g2: Add XIP support Prakriti Sharma

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=20261119100513.433044-3-prakriti@synopsys.com \
    --to=prakriti.sharma@synopsys.com \
    --cc=Siddhant.Kumar@synopsys.com \
    --cc=broonie@kernel.org \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=krzk+dt@kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-spi@vger.kernel.org \
    --cc=p.zabel@pengutronix.de \
    --cc=robh@kernel.org \
    /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®