Devicetree
 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 6/6] spi: dw-g2: Add XIP support
Date: Thu, 19 Nov 2026 15:35:13 +0530	[thread overview]
Message-ID: <20261119100513.433044-7-prakriti@synopsys.com> (raw)
In-Reply-To: <20261119100513.433044-1-prakriti@synopsys.com>

Add memory-mapped execute-in-place through the spi-mem direct-mapping
helpers.

NOR page-program writes stay on the indirect FIFO path. XIP issues a
separate SPI transaction per access, and page program needs one
continuous transaction. Direct mapping can be switched at runtime
through debugfs.

Signed-off-by: Prakriti Sharma <prakriti@synopsys.com>
Signed-off-by: Siddhant Kumar <sidkumar@synopsys.com>
---
 drivers/spi/spi-dw-g2-core.c | 1074 +++++++++++++++++++++++++++++++++-
 drivers/spi/spi-dw-g2-mmio.c |  263 ++++++++-
 drivers/spi/spi-dw-g2.h      |  166 +++++-
 3 files changed, 1469 insertions(+), 34 deletions(-)

diff --git a/drivers/spi/spi-dw-g2-core.c b/drivers/spi/spi-dw-g2-core.c
index a94d4a7870df..2e265459381d 100644
--- a/drivers/spi/spi-dw-g2-core.c
+++ b/drivers/spi/spi-dw-g2-core.c
@@ -36,8 +36,112 @@ static const struct debugfs_reg32 dw_spi_g2_dbg_regs[] = {
 	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_DBG_REG("CS0_RX_SAMPLE_DLY", DW_SPI_G2_RX_SAMPLE_DELAY(0)),
+	DW_SPI_G2_DBG_REG("CS1_RX_SAMPLE_DLY", DW_SPI_G2_RX_SAMPLE_DELAY(1)),
+	DW_SPI_G2_DBG_REG("CS2_RX_SAMPLE_DLY", DW_SPI_G2_RX_SAMPLE_DELAY(2)),
+	DW_SPI_G2_DBG_REG("CS3_RX_SAMPLE_DLY", DW_SPI_G2_RX_SAMPLE_DELAY(3)),
+	DW_SPI_G2_DBG_REG("CS0_DDR_DRV_EDGE",  DW_SPI_G2_DDR_DRIVE_EDGE(0)),
+	DW_SPI_G2_DBG_REG("CS1_DDR_DRV_EDGE",  DW_SPI_G2_DDR_DRIVE_EDGE(1)),
+	DW_SPI_G2_DBG_REG("CS2_DDR_DRV_EDGE",  DW_SPI_G2_DDR_DRIVE_EDGE(2)),
 };
 
+static int xip_mode_get(void *data, u64 *val)
+{
+	struct dw_spi_g2 *dws = data;
+	*val = dws->use_xip ? 1 : 0;
+	return 0;
+}
+
+static int xip_mode_set(void *data, u64 val)
+{
+	struct dw_spi_g2 *dws = data;
+
+	if (val != 0 && val != 1)
+		return -EINVAL;
+
+	if (val && !dws->xip_mem) {
+		dev_err(dws->dev, "Cannot enable XIP: no memory-mapped region\n");
+		return -EINVAL;
+	}
+
+	dws->use_xip = !!val;
+	dev_info(dws->dev, "Transfer mode set to %s\n",
+		 dws->use_xip ? "XIP (direct)" : "indirect (FIFO)");
+
+	return 0;
+}
+
+DEFINE_DEBUGFS_ATTRIBUTE(xip_mode_fops, xip_mode_get, xip_mode_set, "%llu\n");
+
+
+static int xip_continuous_mode_get(void *data, u64 *val)
+{
+	struct dw_spi_g2 *dws = data;
+	*val = dws->xip_continuous_mode ? 1 : 0;
+	return 0;
+}
+
+static int xip_continuous_mode_set(void *data, u64 val)
+{
+	struct dw_spi_g2 *dws = data;
+
+	if (val != 0 && val != 1)
+		return -EINVAL;
+
+	if (val && !dws->xip_mem) {
+		dev_err(dws->dev,
+			"Cannot enable XIP continuous mode: no XIP region\n");
+		return -EINVAL;
+	}
+
+	dws->xip_continuous_mode = !!val;
+	dev_info(dws->dev, "XIP continuous transfer mode: %s\n",
+		 dws->xip_continuous_mode ? "enabled" : "disabled");
+
+	if (dws->xip_continuous_mode)
+		dev_info(dws->dev,
+			 "Requires flash command supporting continuous read (e.g., 0xEB Quad I/O)\n");
+
+	return 0;
+}
+
+DEFINE_DEBUGFS_ATTRIBUTE(xip_continuous_mode_fops, xip_continuous_mode_get,
+			 xip_continuous_mode_set, "%llu\n");
+
+static int xip_prefetch_mode_get(void *data, u64 *val)
+{
+	struct dw_spi_g2 *dws = data;
+	*val = dws->xip_prefetch_mode ? 1 : 0;
+	return 0;
+}
+
+static int xip_prefetch_mode_set(void *data, u64 val)
+{
+	struct dw_spi_g2 *dws = data;
+
+	if (val != 0 && val != 1)
+		return -EINVAL;
+
+	if (val && !dws->xip_mem) {
+		dev_err(dws->dev,
+			"Cannot enable XIP prefetch mode: no XIP region\n");
+		return -EINVAL;
+	}
+
+	dws->xip_prefetch_mode = !!val;
+	dev_info(dws->dev, "XIP prefetch mode: %s\n",
+		 dws->xip_prefetch_mode ? "enabled" : "disabled");
+
+	if (dws->xip_prefetch_mode)
+		dev_info(dws->dev,
+			 "Requires flash command supporting continuous read (e.g., 0xEB Quad I/O)\n");
+
+	return 0;
+}
+
+DEFINE_DEBUGFS_ATTRIBUTE(xip_prefetch_mode_fops, xip_prefetch_mode_get,
+			 xip_prefetch_mode_set, "%llu\n");
+
 /**
  * dw_spi_g2_debugfs_init - Create debugfs entries for register inspection
  * @dws: Driver state
@@ -61,6 +165,11 @@ static void dw_spi_g2_debugfs_init(struct dw_spi_g2 *dws)
 	dws->regset.nregs = ARRAY_SIZE(dw_spi_g2_dbg_regs);
 
 	debugfs_create_regset32("registers", 0400, dws->debugfs, &dws->regset);
+	debugfs_create_file("xip_mode", 0644, dws->debugfs, dws, &xip_mode_fops);
+	debugfs_create_file("xip_continuous_mode", 0644, dws->debugfs, dws,
+			    &xip_continuous_mode_fops);
+	debugfs_create_file("xip_prefetch_mode", 0644, dws->debugfs, dws,
+			    &xip_prefetch_mode_fops);
 }
 
 /**
@@ -152,28 +261,61 @@ int dw_spi_g2_setup(struct spi_device *spi)
 	dw_spi_g2_target_disable(dws, dws->cs);
 	dw_spi_g2_writel(dws->regs, DW_SPI_G2_BAUDR(dws->cs), baud);
 
+	/* Configure RX sample delay for chip select */
+	if (dws->cs < DW_SPI_G2_MAX_CS) {
+		u32 rx_dly_ns;
+
+		if (device_property_read_u32(&spi->dev, "rx-sample-delay-ns",
+					     &rx_dly_ns))
+			rx_dly_ns = dws->def_rx_sample_dly_ns;
+
+		dws->rx_sample_dly[dws->cs] =
+			DIV_ROUND_CLOSEST(rx_dly_ns,
+					  NSEC_PER_SEC / dws->max_freq);
+	}
+
 	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);
+		"setup: CS=%u mode=%u bpw=%u speed=%u baud=%u rx_dly=%u\n",
+		dws->cs, spi->mode, spi->bits_per_word, speed, baud,
+		dws->cs < DW_SPI_G2_MAX_CS ? dws->rx_sample_dly[dws->cs] : 0);
 
 	return 0;
 }
 
-static void dw_spi_g2_controller_reset(struct dw_spi_g2 *dws)
+/**
+ * dw_spi_g2_set_sampling_mode - Configure RX sampling mode
+ * @dws: Driver state
+ * @cs: Chip select
+ * @mode: Sampling mode to enable
+ *
+ * RX_DELAY uses RX_SAMPLE_DELAY. DATA_STROBE uses the flash DQS/RXDS
+ * input for DTR transfers. Must be called with SSI disabled.
+ */
+void dw_spi_g2_set_sampling_mode(struct dw_spi_g2 *dws, u8 cs,
+				 enum dw_spi_g2_sampling_mode mode)
 {
-	int drain = 0;
+	u32 ctrlr0, spictrlr0;
 
-	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);
+	ctrlr0 = dw_spi_g2_readl(dws->regs, DW_SPI_G2_CTRLR0(cs));
+	spictrlr0 = dw_spi_g2_readl(dws->regs, DW_SPI_G2_SPI_CTRLR0(cs));
 
-	/* 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++;
+	switch (mode) {
+	case DW_SPI_G2_SAMPLING_RX_DELAY:
+		/* Disable CLK_LOOP_EN and SPI_RXDS_EN for basic RX_SAMPLE_DELAY */
+		ctrlr0 &= ~DW_SPI_G2_CTRLR0_CLK_LOOP_EN;
+		spictrlr0 &= ~DW_SPI_G2_SPI_CTRLR0_INST_RXDS_EN_MASK;
+		break;
+
+
+	case DW_SPI_G2_SAMPLING_DATA_STROBE:
+		/* Enable SPI_RXDS_EN, disable CLK_LOOP_EN for DQS/strobe mode */
+		ctrlr0 &= ~DW_SPI_G2_CTRLR0_CLK_LOOP_EN;
+		spictrlr0 |= DW_SPI_G2_SPI_CTRLR0_INST_RXDS_EN_MASK;
+		break;
 	}
+
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_CTRLR0(cs), ctrlr0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SPI_CTRLR0(cs), spictrlr0);
 }
 
 /**
@@ -230,6 +372,30 @@ static u32 dw_spi_g2_build_ctrlr0(struct dw_spi_g2 *dws, u8 tmod, u8 frf)
 	return ctrlr0;
 }
 
+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);
+	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++;
+	}
+
+	/* Update RX sample delay for current CS if value differs. */
+	if (dws->cs < DW_SPI_G2_MAX_CS &&
+	    dws->rx_sample_dly[dws->cs] != dws->cur_rx_sample_dly) {
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_RX_SAMPLE_DELAY(dws->cs),
+				 dws->rx_sample_dly[dws->cs]);
+		dws->cur_rx_sample_dly = dws->rx_sample_dly[dws->cs];
+	}
+}
+
 /**
  * dw_spi_g2_get_frf - Determine frame format from operation bus widths
  * @op: SPI memory operation
@@ -456,16 +622,29 @@ static int dw_spi_g2_cmd_only(struct dw_spi_g2 *dws,
 {
 	u8 buf[8];
 	u32 len;
+	u32 i;
 	int ret;
 
+	dev_dbg(dws->dev, "cmd_only: cmd=0x%02x addr=0x%llx\n",
+		op->cmd.opcode, op->addr.val);
+
 	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_target_enable(dws, dws->cs);
+	dw_spi_g2_enable(dws, true);
+
+	for (i = 0; i < len; i++)
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_DR0, buf[i]);
+
+	dw_spi_g2_cs_assert(dws, dws->cs);
+	dw_spi_g2_wait_idle(dws);
+	ret = 0;
+
 	dw_spi_g2_transfer_end(dws);
 	dw_spi_g2_controller_reset(dws);
+
 	return ret;
 }
 
@@ -629,6 +808,90 @@ static int dw_spi_g2_reg_op(struct dw_spi_g2 *dws, const struct spi_mem_op *op)
 	return ret;
 }
 
+/**
+ * dw_spi_g2_op_freq - Choose the SPI clock frequency for a given op
+ * @dws: Driver state
+ * @op: SPI memory operation
+ *
+ * Prefer op->max_freq. If it is unset, use a conservative fraction of
+ * the controller clock rather than dws->max_freq, which can overclock
+ * a slow flash.
+ *
+ * Return: Frequency in Hz to program into BAUDR.
+ */
+u32 dw_spi_g2_op_freq(struct dw_spi_g2 *dws,
+		      const struct spi_mem_op *op)
+{
+	u32 f = op->max_freq;
+
+	if (!f)
+		f = dws->max_freq / 8;
+
+	return f;
+}
+
+/**
+ * dw_spi_g2_program_baudr - Program per-CS BAUDR for a given target freq
+ * @dws: Driver state
+ * @freq: Target SPI clock frequency in Hz
+ *
+ * SCKDV must be even (or 1 for passthrough). Must be called with SSI
+ * disabled. If @freq is 0, fall back to a conservative fraction of the
+ * controller clock. No-op if no valid frequency is available or the
+ * active CS is out of range.
+ */
+void dw_spi_g2_program_baudr(struct dw_spi_g2 *dws, u32 freq)
+{
+	u32 div, baud;
+
+	if (dws->cs >= DW_SPI_G2_MAX_CS)
+		return;
+
+	if (!freq)
+		freq = dws->max_freq / 8;
+	if (!freq)
+		return;
+
+	div = DIV_ROUND_UP(dws->clk_rate, freq);
+	if (div <= 1) {
+		baud = 1;	/* Passthrough mode */
+	} else {
+		if (div & 1)
+			div++;	/* SCKDV must be even */
+		baud = div;
+	}
+
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_BAUDR(dws->cs), baud);
+}
+
+/**
+ * dw_spi_g2_update_ddr_drive_edge - Program per-CS DDR transmit drive edge
+ * @dws: Driver state
+ * @op: SPI memory operation (must have a DDR/DTR phase)
+ *
+ * At BAUDR 1 or 2 the drive edge is set for edge-aligned data so the TX
+ * delay line can centre the clock; at higher divisors the register returns
+ * to 0 (edge-aligned with sclk_out, default DDR behaviour).
+ */
+static void dw_spi_g2_update_ddr_drive_edge(struct dw_spi_g2 *dws,
+					    const struct spi_mem_op *op)
+{
+	u32 baud;
+
+	if (!op->cmd.dtr && !op->addr.dtr && !op->data.dtr)
+		return;
+
+	if (dws->cs >= DW_SPI_G2_MAX_CS)
+		return;
+
+	baud = dw_spi_g2_readl(dws->regs, DW_SPI_G2_BAUDR(dws->cs)) & 0xFF;
+	if (!baud)
+		baud = 1;
+
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_DDR_DRIVE_EDGE(dws->cs),
+			 (baud <= 2) ? 1 : 0);
+}
+
 /**
  * Indirect read operations
  */
@@ -658,6 +921,12 @@ static int dw_spi_g2_indirect_read_setup(struct dw_spi_g2 *dws,
 			return -EINVAL;
 		}
 		dummy_cycles = (op->dummy.nbytes * 8) / op->dummy.buswidth;
+		/*
+		 * In DTR mode two bits are clocked per cycle, so the dummy
+		 * phase needs half as many controller cycles as in SDR mode.
+		 */
+		if (op->data.dtr && dummy_cycles)
+			dummy_cycles /= 2;
 		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);
@@ -693,11 +962,25 @@ static int dw_spi_g2_indirect_read_setup(struct dw_spi_g2 *dws,
 		spictrlr0 |= DW_SPI_G2_SPI_CTRLR0_INST_DDR_EN_MASK;
 	if (op->addr.dtr || op->data.dtr)
 		spictrlr0 |= DW_SPI_G2_SPI_CTRLR0_DDR_EN_MASK;
-	if (op->data.dtr)
-		spictrlr0 |= DW_SPI_G2_SPI_CTRLR0_INST_RXDS_EN_MASK;
 
+	/*
+	 * DTR mode with data strobe: set RXDS_EN and enforce mutual
+	 * exclusivity with the RX-delay sampling mode.
+	 */
+	if (op->data.dtr) {
+		spictrlr0 |= DW_SPI_G2_SPI_CTRLR0_INST_RXDS_EN_MASK;
+		dw_spi_g2_set_sampling_mode(dws, dws->cs,
+					    DW_SPI_G2_SAMPLING_DATA_STROBE);
+	} else {
+		dw_spi_g2_set_sampling_mode(dws, dws->cs,
+					    DW_SPI_G2_SAMPLING_RX_DELAY);
+	}
 	dw_spi_g2_writel(dws->regs, DW_SPI_G2_SPI_CTRLR0(dws->cs), spictrlr0);
 
+	/* Per-op BAUDR: tuned ops use op->max_freq, others cap to safe rate */
+	dw_spi_g2_program_baudr(dws, dw_spi_g2_op_freq(dws, op));
+	dw_spi_g2_update_ddr_drive_edge(dws, op);
+
 	dw_spi_g2_writel(dws->regs, DW_SPI_G2_TXFTLR, 0);
 	dw_spi_g2_writel(dws->regs, DW_SPI_G2_RXFTLR,
 			 min_t(u32, (dws->fifo_len / 2) - 1,
@@ -823,9 +1106,25 @@ static void dw_spi_g2_indirect_write_setup(struct dw_spi_g2 *dws,
 	if (op->addr.dtr || op->data.dtr)
 		spictrlr0 |= DW_SPI_G2_SPI_CTRLR0_DDR_EN_MASK;
 
+	/*
+	 * For writes, sampling mode is less critical but enforce
+	 * mutual exclusivity for consistency with read path.
+	 */
+	if (op->data.dtr) {
+		dw_spi_g2_set_sampling_mode(dws, dws->cs,
+					    DW_SPI_G2_SAMPLING_DATA_STROBE);
+	} else {
+		dw_spi_g2_set_sampling_mode(dws, dws->cs,
+					    DW_SPI_G2_SAMPLING_RX_DELAY);
+	}
 	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), spictrlr0);
+
+	/* Per-op BAUDR: tuned ops use op->max_freq, others cap to safe rate */
+	dw_spi_g2_program_baudr(dws, dw_spi_g2_op_freq(dws, op));
+	dw_spi_g2_update_ddr_drive_edge(dws, op);
+
 	dw_spi_g2_writel(dws->regs, DW_SPI_G2_TXFTLR, 0);
 	dw_spi_g2_writel(dws->regs, DW_SPI_G2_RXFTLR, 0);
 }
@@ -893,6 +1192,679 @@ static int dw_spi_g2_indirect_write(struct dw_spi_g2 *dws,
 	return ret;
 }
 
+/*
+ * ========================================================================
+ * XIP (Direct Mapping) Support
+ * ========================================================================
+ */
+
+/**
+ * dw_spi_g2_xip_setup - Configure XIP mode for direct memory access
+ * @dws: Driver state
+ * @op: SPI memory operation template
+ * @is_write: true for write operations, false for read operations
+ *
+ * Configures the XIP registers to enable direct memory-mapped access.
+ * This allows CPU to read/write flash directly via memory bus without
+ * going through the SPI controller's data registers.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int dw_spi_g2_xip_setup(struct dw_spi_g2 *dws,
+			       const struct spi_mem_op *op,
+			       bool is_write)
+{
+	u32 xip_ctrl = 0;
+	u32 dummy_cycles = 0;
+	int tt;
+
+	if (!dws->xip_mem) {
+		dev_err(dws->dev, "XIP memory region not mapped\n");
+		return -EINVAL;
+	}
+
+	tt = dw_spi_g2_get_tt(op);
+	if (tt < 0) {
+		dev_err(dws->dev, "Unsupported XIP transfer type\n");
+		return tt;
+	}
+
+	if (op->dummy.nbytes) {
+		if (!op->dummy.buswidth || op->dummy.buswidth > 8)
+			return -EINVAL;
+		dummy_cycles = (op->dummy.nbytes * 8) / op->dummy.buswidth;
+		/*
+		 * In DTR mode two bits are clocked per cycle, so the dummy
+		 * phase needs half as many controller cycles as in SDR mode.
+		 */
+		if (op->data.dtr && dummy_cycles)
+			dummy_cycles /= 2;
+		if (dummy_cycles > DW_SPI_G2_SPI_CTRLR0_WAIT_CYCLES_MAX)
+			return -EINVAL;
+	}
+
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_target_disable(dws, dws->cs);
+
+	if (!is_write) {
+		/* Configure XIP read control */
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_CTRL_FRF_MASK,
+				       dw_spi_g2_get_frf(op));
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_CTRL_TRANS_TYPE_MASK, tt);
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_CTRL_ADDR_L_MASK,
+				       dw_spi_g2_addr_len(op->addr.nbytes));
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_CTRL_INST_L_MASK,
+				       dw_spi_g2_inst_len(op->cmd.nbytes));
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_CTRL_WAIT_CYCLES_MASK,
+				       dummy_cycles);
+		/*
+		 * DFS_HC (Data Frame Size - Hardware Controlled): let the
+		 * XIP engine derive the frame size from the AHB transaction
+		 * width instead of CTRLR0.DFS. With DFS_HC cleared the
+		 * engine uses CTRLR0.DFS (which is 8, since
+		 * ctlr->bits_per_word_mask = SPI_BPW_MASK(8)) and packs
+		 * each AHB beat MSB-byte-first on the wire, which the
+		 * little-endian AXI wrapper stores byte-reversed in memory
+		 * (per-32-bit-word byte-swap on dirmap reads). Mirrors the
+		 * XIP_WR_CTRL_DFS_HC bit already set on the write path.
+		 */
+		xip_ctrl |= DW_SPI_G2_XIP_CTRL_DFS_HC;
+
+		if (op->data.dtr) {
+			xip_ctrl |= DW_SPI_G2_XIP_CTRL_DDR_EN;
+			xip_ctrl |= DW_SPI_G2_XIP_CTRL_RXDS_EN;
+			dw_spi_g2_set_sampling_mode(dws, dws->cs,
+						    DW_SPI_G2_SAMPLING_DATA_STROBE);
+		} else {
+			dw_spi_g2_set_sampling_mode(dws, dws->cs,
+						    DW_SPI_G2_SAMPLING_RX_DELAY);
+		}
+		if (op->cmd.dtr)
+			xip_ctrl |= DW_SPI_G2_XIP_CTRL_INST_DDR_EN;
+		if (op->cmd.opcode != 0)
+			xip_ctrl |= DW_SPI_G2_XIP_CTRL_INST_EN;
+
+		/* Per-op BAUDR: matched ops at op->max_freq, else safe rate */
+		dw_spi_g2_program_baudr(dws,
+					dw_spi_g2_op_freq(dws, op));
+		dw_spi_g2_update_ddr_drive_edge(dws, op);
+
+		/*
+		 * XIP Performance Optimizations
+		 *
+		 * Continuous Transfer Mode (CONT_XFER_EN):
+		 *   When enabled, the controller omits the command byte on
+		 *   subsequent sequential reads from the same CS.
+		 *
+		 *   Requirements:
+		 *   - Flash must support continuous read mode (e.g., 0xEB Fast
+		 *     Read Quad I/O with mode bits)
+		 *   - Must use consistent command across all accesses
+		 *   - CS must remain asserted between transfers
+		 *
+		 *   The controller automatically re-sends the command when:
+		 *   - CS is de-asserted (chip select change)
+		 *   - Transfer type changes (e.g., switching from quad to single)
+		 *
+		 * Prefetch Mode (PREFETCH_EN):
+		 *   The controller speculatively fetches the next cache line
+		 *   when the current access completes, anticipating sequential
+		 *   reads. This reduces latency for instruction fetches during
+		 *   XIP code execution.
+		 *
+		 *   Best for: Sequential code execution, linear data reads
+		 *
+		 * Both features are disabled by default for maximum flash
+		 * compatibility and can be enabled via module parameters or
+		 * device tree properties.
+		 */
+		if (dws->xip_continuous_mode && op->cmd.opcode != 0) {
+			xip_ctrl |= DW_SPI_G2_XIP_CTRL_CONT_XFER_EN;
+
+			/*
+			 * Program XIP_CNT_TIME_OUT
+			 * In continuous mode, this hclk-cycle timeout deselects
+			 * the target if no AHB request arrives within the
+			 * window. Must be written while SSI is disabled.
+			 */
+			dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_CNT_TIME_OUT,
+					 FIELD_PREP(DW_SPI_G2_XIP_XTOC_MASK,
+						    DW_SPI_G2_XIP_XTOC_DEFAULT));
+		}
+
+		if (dws->xip_prefetch_mode)
+			xip_ctrl |= DW_SPI_G2_XIP_CTRL_PREFETCH_EN;
+
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_CTRL(dws->cs),
+				 xip_ctrl);
+
+		if (op->cmd.opcode != 0) {
+			dw_spi_g2_writel(dws->regs,
+					 DW_SPI_G2_XIP_INCR_INST(dws->cs),
+					 op->cmd.opcode);
+			dw_spi_g2_writel(dws->regs,
+					 DW_SPI_G2_XIP_WRAP_INST(dws->cs),
+					 op->cmd.opcode);
+		}
+	} else {
+		/* Configure XIP write control */
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_WR_CTRL_FRF_MASK,
+				       dw_spi_g2_get_frf(op));
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_WR_CTRL_TRANS_TYPE_MASK, tt);
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_WR_CTRL_ADDR_L_MASK,
+				       dw_spi_g2_addr_len(op->addr.nbytes));
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_WR_CTRL_INST_L_MASK,
+				       dw_spi_g2_inst_len(op->cmd.nbytes));
+		xip_ctrl |= FIELD_PREP(DW_SPI_G2_XIP_WR_CTRL_WAIT_CYCLES_MASK,
+				       dummy_cycles);
+		xip_ctrl |= DW_SPI_G2_XIP_WR_CTRL_DFS_HC;
+
+		if (op->data.dtr) {
+			xip_ctrl |= DW_SPI_G2_XIP_WR_CTRL_DDR_EN;
+			dw_spi_g2_set_sampling_mode(dws, dws->cs,
+						    DW_SPI_G2_SAMPLING_DATA_STROBE);
+		} else {
+			dw_spi_g2_set_sampling_mode(dws, dws->cs,
+						    DW_SPI_G2_SAMPLING_RX_DELAY);
+		}
+		if (op->cmd.dtr)
+			xip_ctrl |= DW_SPI_G2_XIP_WR_CTRL_INST_DDR_EN;
+
+		/* Per-op BAUDR: matched ops at op->max_freq, else safe rate */
+		dw_spi_g2_program_baudr(dws,
+					dw_spi_g2_op_freq(dws, op));
+		dw_spi_g2_update_ddr_drive_edge(dws, op);
+
+		dw_spi_g2_writel(dws->regs,
+				 DW_SPI_G2_XIP_WRITE_CTRL(dws->cs),
+				 xip_ctrl);
+
+		if (op->cmd.opcode != 0) {
+			dw_spi_g2_writel(dws->regs,
+					 DW_SPI_G2_XIP_WRITE_INCR_INST(dws->cs),
+					 op->cmd.opcode);
+			dw_spi_g2_writel(dws->regs,
+					 DW_SPI_G2_XIP_WRITE_WRAP_INST(dws->cs),
+					 op->cmd.opcode);
+		}
+	}
+
+	dw_spi_g2_target_enable(dws, dws->cs);
+
+	dev_dbg(dws->dev, "xip_setup: %s cmd=0x%02x addr_bytes=%u dummy=%u cs=%u\n",
+		is_write ? "WRITE" : "READ",
+		op->cmd.opcode, op->addr.nbytes, dummy_cycles, dws->cs);
+
+	return 0;
+}
+
+/**
+ * dw_spi_g2_dirmap_create - Create a direct mapping for XIP access
+ * @desc: Direct mapping descriptor
+ *
+ * Sets up XIP mode configuration for the specified operation template.
+ * The actual memory mapping is expected to be set up by the platform driver.
+ *
+ * This configures both CTRLR0 (for data frame size and SPI mode) and the
+ * XIP-specific registers (for command, address, and transfer type).
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+int dw_spi_g2_dirmap_create(struct spi_mem_dirmap_desc *desc)
+{
+	struct spi_device *spi = desc->mem->spi;
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(spi->controller);
+	const struct spi_mem_op *op = desc->info.op_tmpl;
+	u32 ctrlr0;
+	int ret;
+
+	if (!dws->xip_mem) {
+		dev_dbg(dws->dev, "XIP memory region not available\n");
+		return -EOPNOTSUPP;
+	}
+
+	dev_dbg(dws->dev, "dirmap_create: cmd=0x%02x addr_width=%u dir=%s dummy=%u\n",
+		op->cmd.opcode, op->addr.nbytes,
+		op->data.dir == SPI_MEM_DATA_IN ? "READ" : "WRITE",
+		op->dummy.nbytes);
+
+	dws->cs = spi_get_chipselect(spi, 0);
+	dws->curr_spi = spi;
+
+	/*
+	 * Configure CTRLR0 with data frame size and SPI mode settings.
+	 * XIP mode uses these settings for all memory-mapped accesses.
+	 */
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_target_disable(dws, dws->cs);
+
+	ctrlr0 = dw_spi_g2_build_ctrlr0(dws, DW_SPI_G2_CTRLR0_TMOD_TR,
+					DW_SPI_G2_FRF_STANDARD);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_CTRLR0(dws->cs), ctrlr0);
+
+	/* Configure XIP registers for read/write operations */
+	ret = dw_spi_g2_xip_setup(dws, op,
+				  op->data.dir == SPI_MEM_DATA_OUT);
+	/*
+	 * xip_setup enables the target (sets BIT(cs) in
+	 * DEDICATED_CS_EN) to program per-CS registers.
+	 * Clean it up so stale bits don't leak into
+	 * cmd_only / reg_op operations on other CS lines.
+	 * dirmap_read/write will re-enable when needed.
+	 */
+	dw_spi_g2_target_disable(dws, dws->cs);
+	return ret;
+}
+
+/**
+ * dw_spi_g2_dirmap_read - Direct memory-mapped read from flash
+ * @desc: Direct mapping descriptor
+ * @offs: Offset within the mapped region
+ * @len: Number of bytes to read
+ * @buf: Destination buffer
+ *
+ * Performs direct memory-mapped read using XIP mode. The controller
+ * automatically sends the configured command and address for each access.
+ * Supports 8/16/32-bit data frame sizes for optimal performance.
+ *
+ * Return: Number of bytes read on success, negative error code on failure
+ */
+ssize_t dw_spi_g2_dirmap_read(struct spi_mem_dirmap_desc *desc,
+			      u64 offs, size_t len, void *buf)
+{
+	struct spi_device *spi = desc->mem->spi;
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(spi->controller);
+	void __iomem *src;
+	u32 ctrlr0;
+
+	dws->cs = spi_get_chipselect(spi, 0);
+	dws->curr_spi = spi;
+
+	if (!dws->use_xip) {
+		struct spi_mem_op op = *desc->info.op_tmpl;
+		size_t chunk, done = 0;
+		unsigned int dummy_shift = 0;
+		int ret;
+
+		/* Clear XIP registers so they don't interfere with RO mode */
+		dw_spi_g2_enable(dws, false);
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_SER, 0);
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_WR_SER, 0);
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_CTRL(dws->cs), 0);
+
+		/*
+		 * Fold dummy bytes into the address field.
+		 *
+		 * To handle WAIT_CYCLES in RO mode --
+		 * the RX FIFO stays empty when WAIT_CYCLES > 0.  Work around
+		 * this by absorbing the dummy phase into the address: shift the
+		 * real address left by (dummy_nbytes * 8) bits and zero-pad.
+		 * This makes WAIT_CYCLES=0 while the flash still receives the
+		 * correct number of clock cycles before data.
+		 *
+		 * With TT1 (1-1-x), both address and folded-dummy bits travel
+		 * on the standard single lane, so the flash sees:
+		 *   [real addr MSB..LSB] [zero-pad dummy clocks] [data on x lanes]
+		 */
+		if (op.dummy.nbytes) {
+			dummy_shift = op.dummy.nbytes * 8;
+			op.addr.nbytes += op.dummy.nbytes;
+			op.dummy.nbytes = 0;
+		}
+
+		while (done < len) {
+			chunk = min_t(size_t, len - done, dws->fifo_len);
+
+			op.addr.val = (u64)(offs + done) << dummy_shift;
+			op.data.nbytes = chunk;
+			op.data.buf.in = (u8 *)buf + done;
+
+			ret = dw_spi_g2_indirect_read(dws, &op);
+			if (ret)
+				return ret;
+
+			done += chunk;
+		}
+
+		return (ssize_t)len;
+	}
+
+	if (!dws->xip_mem)
+		return -EOPNOTSUPP;
+
+	if (offs + len > dws->xip_len)
+		return -EINVAL;
+
+	/*
+	 * Restore full XIP register state. An indirect transfer (from a
+	 * prior mode switch) may have left CTRLR0 in TMOD_RO/TO and
+	 * SPI_CTRLR0 with non-XIP framing, which corrupts XIP accesses.
+	 */
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_target_disable(dws, dws->cs);
+	ctrlr0 = dw_spi_g2_build_ctrlr0(dws, DW_SPI_G2_CTRLR0_TMOD_TR,
+					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_CTRLR1(dws->cs), 0);
+	dw_spi_g2_xip_setup(dws, desc->info.op_tmpl, false);
+
+	src = dws->xip_mem + offs;
+
+	/* Enable XIP mode for read */
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_SER, BIT(dws->cs));
+	dw_spi_g2_enable(dws, true);
+
+	/*
+	 * PIO read from XIP window. The XIP engine turns each AHB read
+	 * into a (cmd + addr + dummy + data) SPI transaction.
+	 */
+	memcpy_fromio(buf, src, len);
+
+	/* Disable XIP mode and clean up DEDICATED_CS_EN */
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_SER, 0);
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_target_disable(dws, dws->cs);
+
+	return (ssize_t)len;
+}
+
+/**
+ * dw_spi_g2_dirmap_write_nor_xip - byte-by-byte NOR XIP write hack
+ * @dws:  driver state
+ * @desc: dirmap descriptor (XIP write template lives in info.op_tmpl)
+ * @offs: byte offset inside the flash
+ * @len:  byte count to program
+ * @buf:  data to program
+ *
+ * Single-byte XIP write protocol: for every byte we issue WREN
+ * out-of-band, arm the XIP write engine, do exactly one writeb() into
+ * the XIP window (the engine emits one cmd+addr+1-data Page Program),
+ * then poll SR1 until WIP clears.
+ *
+ * Functionally correct but ~3 SPI transactions per byte, so dramatically
+ * slower than the indirect-FIFO path (one cmd+addr+up-to-256 Page Program
+ * per call). It is selected automatically whenever XIP is enabled on the
+ * controller (dws->use_xip && dws->xip_mem != NULL), so any NOR write
+ * issued through dirmap_write() exercises the XIP-write engine end-to-end.
+ */
+static ssize_t dw_spi_g2_dirmap_write_nor_xip(struct dw_spi_g2 *dws,
+					      struct spi_mem_dirmap_desc *desc,
+					      u64 offs, size_t len,
+					      const void *buf)
+{
+	const struct spi_mem_op wren_op = SPI_MEM_OP(SPI_MEM_OP_CMD(DW_SPI_G2_NOR_OP_WREN, 1),
+						     SPI_MEM_OP_NO_ADDR,
+						     SPI_MEM_OP_NO_DUMMY,
+						     SPI_MEM_OP_NO_DATA);
+	const u8 *src = buf;
+	void __iomem *dst;
+	ssize_t result;
+	u32 ctrlr0;
+	u8 sr1;
+	size_t i;
+	int ret;
+
+	if (!dws->xip_mem)
+		return -EOPNOTSUPP;
+
+	if (len > dws->xip_len || offs > dws->xip_len - len)
+		return -EINVAL;
+
+	dst = dws->xip_mem + offs;
+
+	dev_dbg(dws->dev,
+		"dirmap_write_nor_xip: BEGIN offs=0x%llx len=%zu (byte-by-byte WREN/WIP)\n",
+		(unsigned long long)offs, len);
+
+	for (i = 0; i < len; i++) {
+		const struct spi_mem_op rdsr_op =
+			SPI_MEM_OP(SPI_MEM_OP_CMD(DW_SPI_G2_NOR_OP_RDSR1, 1),
+				   SPI_MEM_OP_NO_ADDR,
+				   SPI_MEM_OP_NO_DUMMY,
+				   SPI_MEM_OP_DATA_IN(1, &sr1, 1));
+		unsigned long deadline;
+
+		dev_dbg(dws->dev,
+			"dirmap_write_nor_xip: byte %zu/%zu @ +0x%zx\n",
+			i + 1, len, (size_t)offs + i);
+
+		/* WREN: latch the write-enable bit so the next Page Program is accepted. */
+		ret = dw_spi_g2_cmd_only(dws, &wren_op);
+		if (ret) {
+			dev_err(dws->dev,
+				"XIP NOR write: WREN failed at byte %zu: %d\n",
+				i, ret);
+			result = ret;
+			goto out_unwind;
+		}
+
+		dw_spi_g2_enable(dws, false);
+		dw_spi_g2_target_disable(dws, dws->cs);
+
+		ctrlr0 = dw_spi_g2_build_ctrlr0(dws,
+						DW_SPI_G2_CTRLR0_TMOD_TR,
+						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_CTRLR1(dws->cs), 0);
+		dw_spi_g2_xip_setup(dws, desc->info.op_tmpl, true);
+
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_WR_SER,
+				 BIT(dws->cs));
+		dw_spi_g2_enable(dws, true);
+
+		writeb(src[i], dst + i);
+
+		dw_spi_g2_wait_idle(dws);
+
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_WR_SER, 0);
+		dw_spi_g2_enable(dws, false);
+		dw_spi_g2_target_disable(dws, dws->cs);
+
+		/* WIP poll: spin on SR1.WIP until the program completes. */
+		sr1 = 0;
+		deadline = jiffies +
+			   msecs_to_jiffies(DW_SPI_G2_NOR_WIP_TIMEOUT_MS);
+		do {
+			ret = dw_spi_g2_reg_op(dws, &rdsr_op);
+			if (ret) {
+				dev_err(dws->dev,
+					"XIP NOR write: WIP poll failed at byte %zu: %d\n",
+					i, ret);
+				result = ret;
+				goto out_unwind;
+			}
+			if (!(sr1 & DW_SPI_G2_NOR_SR1_WIP))
+				break;
+			if (time_after(jiffies, deadline)) {
+				dev_err(dws->dev,
+					"XIP NOR write: WIP timeout at byte %zu\n",
+					i);
+				result = -ETIMEDOUT;
+				goto out_unwind;
+			}
+			udelay(1);
+		} while (1);
+	}
+
+	dev_dbg(dws->dev,
+		"dirmap_write_nor_xip: END   offs=0x%llx len=%zu OK\n",
+		(unsigned long long)offs, len);
+
+	return (ssize_t)len;
+
+out_unwind:
+	/*
+	 * On any error mid-loop the XIP-write engine may be left armed
+	 * (XIP_WR_SER set, SSI enabled). Tear it down so the next op sees
+	 * a clean controller state regardless of where the failure landed.
+	 */
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_WR_SER, 0);
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_target_disable(dws, dws->cs);
+	return result;
+}
+
+/**
+ * dw_spi_g2_dirmap_write - Direct memory-mapped write to flash
+ * @desc: Direct mapping descriptor
+ * @offs: Offset within the mapped region
+ * @len: Number of bytes to write
+ * @buf: Source buffer
+ *
+ * Performs direct memory-mapped write using XIP mode. The controller
+ * automatically sends the configured command and address for each access.
+ * Supports 8/16/32-bit data frame sizes for optimal performance.
+ *
+ * Routing rules:
+ *   - NAND Program Load (addr_nbytes == 2): XIP burst path, pushed as a
+ *     writeb() loop. The on-die page buffer auto-increments the column
+ *     counter on each transaction; the per-byte writeb() pace is required
+ *     because this controller's XIP-write engine only emits the first
+ *     byte of each multi-beat AHB store, so any wider PIO/DMA write
+ *     would corrupt the payload past the first byte of each beat.
+ *   - NOR Page Program (addr_nbytes >= 3) with XIP enabled: byte-by-byte
+ *     XIP-write helper (dw_spi_g2_dirmap_write_nor_xip). The
+ *     XIP_WRITE_CTRL register has no auto-WREN bit, so a bursted XIP
+ *     write to NOR would drop everything past the first transaction
+ *     (write-enable cleared). Doing one WREN + 1-byte XIP store + WIP poll per byte
+ *     is slow but functional.
+ *   - NOR Page Program (addr_nbytes >= 3) with XIP disabled: indirect
+ *     FIFO path. Builds one cmd+addr+up-to-256-data SPI transaction in
+ *     software; correct and dramatically faster than the XIP-write
+ *     helper, used as a fallback when no XIP region is mapped.
+ *
+ * Return: Number of bytes written on success, negative error code on failure
+ */
+ssize_t dw_spi_g2_dirmap_write(struct spi_mem_dirmap_desc *desc,
+			       u64 offs, size_t len, const void *buf)
+{
+	struct spi_device *spi = desc->mem->spi;
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(spi->controller);
+	void __iomem *dst;
+	u32 ctrlr0;
+	bool use_indirect = false;
+
+	dws->cs = spi_get_chipselect(spi, 0);
+	dws->curr_spi = spi;
+
+	/*
+	 * NOR Page Program (addr_nbytes >= 3) cannot ride the XIP-write
+	 * engine in burst mode -- the engine emits one cmd+addr+data SPI
+	 * transaction per AHB write but the SPI-NOR framework only issues
+	 * WREN once before dirmap_write(), so every transaction past the
+	 * first arrives with write-enable cleared and is silently dropped.
+	 * NAND Program Load (addr_nbytes == 2) is XIP-friendly because the
+	 * on-die page buffer has no per-byte write-enable gating, so it goes
+	 * to the NAND-XIP-BURST path below.
+	 */
+	if (!dws->use_xip || desc->info.op_tmpl->addr.nbytes >= 3)
+		use_indirect = true;
+
+	/*
+	 * NOR with XIP enabled: route through the byte-by-byte XIP-write
+	 * helper so the XIP-write engine is exercised end-to-end.
+	 */
+	if (use_indirect && dws->use_xip && dws->xip_mem &&
+	    desc->info.op_tmpl->addr.nbytes >= 3) {
+		dev_info(dws->dev,
+			 "dirmap_write: ROUTE=NOR-XIP cmd=0x%02x offs=0x%llx len=%zu\n",
+			 desc->info.op_tmpl->cmd.opcode,
+			 (unsigned long long)offs, len);
+		return dw_spi_g2_dirmap_write_nor_xip(dws, desc, offs, len,
+						      buf);
+	}
+
+	if (use_indirect) {
+		struct spi_mem_op op = *desc->info.op_tmpl;
+		int ret;
+
+		dev_info(dws->dev,
+			 "dirmap_write: ROUTE=NOR-INDIRECT-FIFO cmd=0x%02x offs=0x%llx len=%zu\n",
+			 op.cmd.opcode, (unsigned long long)offs, len);
+
+		/*
+		 * dirmap_create configured XIP_WRITE_CTRL with opcode,
+		 * address length, etc.  These non-zero values can cause
+		 * the controller to misinterpret a plain FIFO (TO-mode)
+		 * write.  Zero the XIP write registers so the indirect
+		 * path behaves identically to exec_mem_op.
+		 */
+		dw_spi_g2_enable(dws, false);
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_WR_SER, 0);
+		dw_spi_g2_writel(dws->regs,
+				 DW_SPI_G2_XIP_WRITE_CTRL(dws->cs), 0);
+
+		op.addr.val = offs;
+		op.data.nbytes = len;
+		op.data.buf.out = buf;
+
+		ret = dw_spi_g2_indirect_write(dws, &op);
+		return ret ? ret : (ssize_t)len;
+	}
+
+	/* XIP write path — only reached for NAND Program Load */
+	if (!dws->xip_mem)
+		return -EOPNOTSUPP;
+
+	if (offs + len > dws->xip_len)
+		return -EINVAL;
+
+	dev_info(dws->dev,
+		 "dirmap_write: ROUTE=NAND-XIP cmd=0x%02x offs=0x%llx len=%zu\n",
+		 desc->info.op_tmpl->cmd.opcode,
+		 (unsigned long long)offs, len);
+
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_target_disable(dws, dws->cs);
+	ctrlr0 = dw_spi_g2_build_ctrlr0(dws, DW_SPI_G2_CTRLR0_TMOD_TR,
+					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_CTRLR1(dws->cs), 0);
+	dw_spi_g2_xip_setup(dws, desc->info.op_tmpl, true);
+
+	dst = dws->xip_mem + offs;
+
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_WR_SER, BIT(dws->cs));
+	dw_spi_g2_enable(dws, true);
+
+	/*
+	 * PIO write into the XIP window. The XIP engine turns every AHB
+	 * write into one (cmd + addr + data) SPI transaction, but on
+	 * this controller only the first byte of each AHB beat is shifted
+	 * out to the flash -- a multi-byte AHB store (writel/writeq, as
+	 * memcpy_toio() emits on arm64 with the MMU on) drops every byte
+	 * past the first. The corruption pattern in flash is unmistakable:
+	 *   buf[0..7]   = 00 01 02 03 04 05 06 07
+	 *   flash[0..7] = 00 04 ff ff ff ff ff ff   <- only +0 and +4 land
+	 * confirming two 32-bit AHB beats per writeq, each beat emitting
+	 * only its low byte. We must therefore push the payload as a
+	 * writeb() loop so every byte is its own AHB beat -> its own SPI
+	 * Program-Load transaction. The on-die NAND page buffer
+	 * auto-increments its column counter on each transaction, so the
+	 * full page lands correctly.
+	 */
+	{
+		const u8 *src = buf;
+		size_t i;
+
+		for (i = 0; i < len; i++)
+			writeb(src[i], dst + i);
+	}
+
+	dw_spi_g2_wait_idle(dws);
+
+	/* Disable XIP WR mode and clean up DEDICATED_CS_EN */
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_XIP_WR_SER, 0);
+	dw_spi_g2_enable(dws, false);
+	dw_spi_g2_target_disable(dws, dws->cs);
+
+	return (ssize_t)len;
+}
+
 /*
  * ========================================================================
  * SPI-MEM interface
@@ -938,8 +1910,20 @@ static bool dw_spi_g2_supports_mem_ops(struct spi_mem *mem,
 	return spi_mem_default_supports_op(mem, op);
 }
 
+/*
+ * Controller capabilities advertised to the spi-mem core:
+ *   - .dtr = true: controller can run DTR (octal-DTR / DDR) phases.
+ *   - .per_op_freq = true: dw_spi_g2_program_baudr() reprograms BAUDR
+ *     at the start of every op, so the spi-mem core may set
+ *     op->max_freq below mem->spi->max_speed_hz on a per-op basis
+ *     (e.g. SPI-NAND cache reads capping at ~50-104 MHz, or an
+ *     SFDP-derived per-op cap). Without this flag, spi-mem rejects
+ *     any op where op->max_freq differs from mem->spi->max_speed_hz
+ *     (see spi-mem.c::spi_mem_check_op()).
+ */
 static const struct spi_controller_mem_caps dw_spi_g2_mem_caps = {
 	.dtr = true,
+	.per_op_freq = true,
 };
 
 int dw_spi_g2_adjust_mem_op_size(struct spi_mem *mem, struct spi_mem_op *op)
@@ -989,6 +1973,13 @@ static int dw_spi_g2_exec_mem_op(struct spi_mem *mem,
 			return -EINVAL;
 		}
 		dummy_cycles = (op->dummy.nbytes * 8) / op->dummy.buswidth;
+		/*
+		 * In DTR mode two bits are clocked per cycle, so halve the
+		 * cycle count derived from dummy.nbytes before checking the
+		 * hardware limit.
+		 */
+		if (op->data.dtr && dummy_cycles)
+			dummy_cycles /= 2;
 		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);
@@ -1029,6 +2020,9 @@ 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,
+	.dirmap_create = dw_spi_g2_dirmap_create,
+	.dirmap_read = dw_spi_g2_dirmap_read,
+	.dirmap_write = dw_spi_g2_dirmap_write,
 };
 
 /*
@@ -1075,15 +2069,7 @@ int dw_spi_g2_init(struct dw_spi_g2 *dws)
 
 	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);
+	dw_spi_g2_hw_init(dws);
 
 	/* Hardware capabilities */
 	dws->fifo_len = dw_spi_g2_detect_fifo_len(dws);
@@ -1126,6 +2112,42 @@ void dw_spi_g2_deinit(struct dw_spi_g2 *dws)
 }
 EXPORT_SYMBOL_NS_GPL(dw_spi_g2_deinit, "SPI_DW_G2_CORE");
 
+/**
+ * dw_spi_g2_hw_init - Re-initialize controller hardware after power-up
+ * @dws: Driver state
+ *
+ * Brings the controller back to a known clean state after clocks are
+ * restored (e.g. resume from suspend). Resets SSI enable, chip selects,
+ * dedicated CS, interrupt mask, and clears any pending interrupts.
+ *
+ * Does NOT reconfigure per-CS transfer registers; those are set up
+ * on-demand by the first spi-mem operation after resume.
+ *
+ * Return: 0 on success
+ */
+int dw_spi_g2_hw_init(struct dw_spi_g2 *dws)
+{
+	u8 cs;
+
+	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);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_IMR, 0);
+	dw_spi_g2_writel(dws->regs, DW_SPI_G2_ICR, DW_SPI_G2_ICR_ALL);
+
+	/*
+	 * Set DDR_DRIVE_EDGE for all CS. Value of 1 means data is driven
+	 * on the falling edge of ssi_clk in DDR mode, which aligns the
+	 * output with the sampling window on the flash side.
+	 */
+	for (cs = 0; cs < DW_SPI_G2_MAX_CS; cs++)
+		dw_spi_g2_writel(dws->regs, DW_SPI_G2_DDR_DRIVE_EDGE(cs), 1);
+
+
+	return 0;
+}
+EXPORT_SYMBOL_NS_GPL(dw_spi_g2_hw_init, "SPI_DW_G2_CORE");
+
 /*
  * ========================================================================
  * Legacy SPI transfer_one interface (not actively used with spi-mem)
diff --git a/drivers/spi/spi-dw-g2-mmio.c b/drivers/spi/spi-dw-g2-mmio.c
index 6ef8f926e0eb..9620ae6e5c23 100644
--- a/drivers/spi/spi-dw-g2-mmio.c
+++ b/drivers/spi/spi-dw-g2-mmio.c
@@ -11,6 +11,42 @@
 
 #include "spi-dw-g2.h"
 
+/*
+ * Module parameter: select transfer mode at load time.
+ *   1 = XIP (memory-mapped direct access)
+ *   0 = indirect (default, FIFO-based, uses exec_mem_op path)
+ *
+ * Can also be changed at runtime via sysfs:
+ *   /sys/devices/.../xip_mode
+ */
+static int xip_mode;
+module_param(xip_mode, int, 0644);
+MODULE_PARM_DESC(xip_mode, "Transfer mode: 0=indirect (default), 1=XIP");
+
+/*
+ * XIP Performance Optimization Parameters
+ *
+ * xip_continuous_mode / xip_prefetch_mode:
+ *   -1 = auto / use DT property (default; DT also defaults to disabled)
+ *    0 = force disabled (overrides DT)
+ *    1 = force enabled (overrides DT, requires flash support, e.g., 0xEB)
+ *
+ * Both modes default to DISABLED unless explicitly enabled via DT or
+ * module parameter, because they require flash commands that support
+ * continuous read mode. Using them with incompatible commands like 0x6B
+ * (Fast Read Quad Output) causes data corruption.
+ */
+static int xip_continuous_mode = -1;
+module_param(xip_continuous_mode, int, 0644);
+MODULE_PARM_DESC(xip_continuous_mode,
+		 "XIP continuous transfer mode: -1=auto/DT (default), 0=disabled, 1=enabled");
+
+static int xip_prefetch_mode = -1;
+module_param(xip_prefetch_mode, int, 0644);
+MODULE_PARM_DESC(xip_prefetch_mode,
+		 "XIP prefetch mode: -1=auto/DT (default), 0=disabled, 1=enabled");
+
+
 struct dw_spi_g2_mmio {
 	struct dw_spi_g2	dws;
 	struct clk		*clk;
@@ -18,6 +54,119 @@ struct dw_spi_g2_mmio {
 	struct reset_control	*rstc;
 };
 
+static ssize_t xip_mode_show(struct device *dev,
+			     struct device_attribute *attr, char *buf)
+{
+	struct spi_controller *ctlr = dev_get_drvdata(dev);
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(ctlr);
+
+	return sysfs_emit(buf, "%d\n", dws->use_xip ? 1 : 0);
+}
+
+static ssize_t xip_mode_store(struct device *dev,
+			      struct device_attribute *attr,
+			      const char *buf, size_t count)
+{
+	struct spi_controller *ctlr = dev_get_drvdata(dev);
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(ctlr);
+	int val;
+
+	if (kstrtoint(buf, 0, &val))
+		return -EINVAL;
+
+	if (val != 0 && val != 1)
+		return -EINVAL;
+
+	if (val && !dws->xip_mem) {
+		dev_err(dev, "Cannot enable XIP: no memory-mapped region available\n");
+		return -EINVAL;
+	}
+
+	dws->use_xip = !!val;
+	dev_info(dev, "Transfer mode set to %s\n",
+		 dws->use_xip ? "XIP (direct)" : "indirect (FIFO)");
+
+	return count;
+}
+
+static DEVICE_ATTR_RW(xip_mode);
+
+static ssize_t xip_continuous_mode_show(struct device *dev,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct spi_controller *ctlr = dev_get_drvdata(dev);
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(ctlr);
+
+	return sysfs_emit(buf, "%d\n", dws->xip_continuous_mode ? 1 : 0);
+}
+
+static ssize_t xip_continuous_mode_store(struct device *dev,
+					 struct device_attribute *attr,
+					 const char *buf, size_t count)
+{
+	struct spi_controller *ctlr = dev_get_drvdata(dev);
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(ctlr);
+	int val;
+
+	if (kstrtoint(buf, 0, &val))
+		return -EINVAL;
+
+	if (val != 0 && val != 1)
+		return -EINVAL;
+
+	if (val && !dws->xip_mem) {
+		dev_err(dev, "Cannot enable continuous mode: no XIP region\n");
+		return -EINVAL;
+	}
+
+	dws->xip_continuous_mode = !!val;
+	dev_info(dev, "XIP continuous transfer mode: %s\n",
+		 dws->xip_continuous_mode ? "enabled" : "disabled");
+
+	return count;
+}
+
+static DEVICE_ATTR_RW(xip_continuous_mode);
+
+static ssize_t xip_prefetch_mode_show(struct device *dev,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	struct spi_controller *ctlr = dev_get_drvdata(dev);
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(ctlr);
+
+	return sysfs_emit(buf, "%d\n", dws->xip_prefetch_mode ? 1 : 0);
+}
+
+static ssize_t xip_prefetch_mode_store(struct device *dev,
+				       struct device_attribute *attr,
+				       const char *buf, size_t count)
+{
+	struct spi_controller *ctlr = dev_get_drvdata(dev);
+	struct dw_spi_g2 *dws = spi_controller_get_devdata(ctlr);
+	int val;
+
+	if (kstrtoint(buf, 0, &val))
+		return -EINVAL;
+
+	if (val != 0 && val != 1)
+		return -EINVAL;
+
+	if (val && !dws->xip_mem) {
+		dev_err(dev, "Cannot enable prefetch: no XIP region\n");
+		return -EINVAL;
+	}
+
+	dws->xip_prefetch_mode = !!val;
+	dev_info(dev, "XIP prefetch mode: %s\n",
+		 dws->xip_prefetch_mode ? "enabled" : "disabled");
+
+	return count;
+}
+
+static DEVICE_ATTR_RW(xip_prefetch_mode);
+
 static int dw_spi_g2_mmio_probe(struct platform_device *pdev)
 {
 	struct dw_spi_g2_mmio *dwsmmio;
@@ -47,6 +196,24 @@ static int dw_spi_g2_mmio_probe(struct platform_device *pdev)
 		goto err_put;
 	}
 
+	/* XIP memory region for direct mapping */
+	mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+	if (mem) {
+		dws->xip_mem = devm_ioremap_resource(&pdev->dev, mem);
+		if (IS_ERR(dws->xip_mem)) {
+			dev_warn(&pdev->dev, "Failed to map XIP region, direct mapping disabled\n");
+			dws->xip_mem = NULL;
+		} else {
+			dws->xip_phys = mem->start;
+			dws->xip_len = resource_size(mem);
+			dev_info(&pdev->dev, "XIP region mapped: phys=0x%llx len=0x%zx\n",
+				 (unsigned long long)dws->xip_phys, dws->xip_len);
+		}
+	} else {
+		dws->xip_mem = NULL;
+		dev_dbg(&pdev->dev, "XIP memory region not specified, direct mapping disabled\n");
+	}
+
 	/*
 	 * IRQ.
 	 *
@@ -126,6 +293,74 @@ static int dw_spi_g2_mmio_probe(struct platform_device *pdev)
 	dev_dbg(dws->dev, "HW_CAPS = 0x%08x\n", dws->hw_caps);
 
 	dws->max_freq = clk_get_rate(dwsmmio->clk);
+
+	/*
+	 * XIP (Direct Mapping) mode configuration.
+	 *
+	 * XIP is enabled ONLY if ALL conditions are met:
+	 *   1. XIP memory region available in DT
+	 *   2. Device tree has snps,xip-enabled property
+	 *   3. Module parameter xip_mode=1 (or runtime sysfs)
+	 *
+	 * This provides safe default (disabled) while allowing controlled enabling.
+	 * Runtime control via sysfs: /sys/devices/.../xip_mode
+	 */
+	bool dt_xip_enabled = device_property_read_bool(&pdev->dev, "snps,xip-enabled");
+	bool param_xip_enabled = xip_mode != 0;
+
+	dws->use_xip = dws->xip_mem && dt_xip_enabled && param_xip_enabled;
+
+	if (dws->xip_mem) {
+		dev_info(&pdev->dev, "XIP mode: %s (DT=%s, param=%s, both required)\n",
+			 dws->use_xip ? "enabled" : "disabled",
+			 dt_xip_enabled ? "yes" : "no",
+			 param_xip_enabled ? "yes" : "no");
+	} else {
+		dev_info(&pdev->dev, "XIP mode: disabled (no memory region in DT)\n");
+	}
+
+	/*
+	 * XIP Performance Optimization Configuration
+	 *
+	 * Both modes default to DISABLED for safety - they require flash
+	 * commands that support continuous read mode (e.g., 0xEB Quad I/O).
+	 * Standard 0x6B (Fast Read Quad Output) does NOT support these
+	 * optimizations and will cause data corruption.
+	 *
+	 * Resolution order (last wins):
+	 *   1. Default: false
+	 *   2. DT property (snps,xip-{continuous,prefetch}-mode) enables
+	 *   3. Module parameter (xip_{continuous,prefetch}_mode) overrides DT
+	 *      Use module param value 0 to force-disable even when DT enables.
+	 *
+	 * Runtime override is also possible via debugfs/sysfs after probe.
+	 */
+	dws->xip_continuous_mode = false;
+	dws->xip_prefetch_mode = false;
+
+	if (dws->xip_mem) {
+		if (device_property_read_bool(&pdev->dev,
+					      "snps,xip-continuous-mode"))
+			dws->xip_continuous_mode = true;
+		if (device_property_read_bool(&pdev->dev,
+					      "snps,xip-prefetch-mode"))
+			dws->xip_prefetch_mode = true;
+
+		/* Module params override DT (>=0 forces explicit value) */
+		if (xip_continuous_mode >= 0)
+			dws->xip_continuous_mode = !!xip_continuous_mode;
+		if (xip_prefetch_mode >= 0)
+			dws->xip_prefetch_mode = !!xip_prefetch_mode;
+
+		dev_info(&pdev->dev, "XIP continuous transfer mode: %s\n",
+			 dws->xip_continuous_mode ? "enabled" : "disabled");
+		dev_info(&pdev->dev, "XIP prefetch mode: %s\n",
+			 dws->xip_prefetch_mode ? "enabled" : "disabled");
+		if (dws->xip_continuous_mode || dws->xip_prefetch_mode)
+			dev_info(&pdev->dev,
+				 "XIP optimizations require flash supporting continuous read (e.g., 0xEB)\n");
+	}
+
 	/* SPI Controller Setup */
 	ctlr->bus_num = of_alias_get_id(pdev->dev.of_node, "spi");
 	if (ctlr->bus_num < 0)
@@ -151,7 +386,29 @@ static int dw_spi_g2_mmio_probe(struct platform_device *pdev)
 	if (ret)
 		goto err_pm;
 
-	dev_info(&pdev->dev, "DW SSI G2 MMIO probed\n");
+	ret = device_create_file(&pdev->dev, &dev_attr_xip_mode);
+	if (ret)
+		dev_warn(&pdev->dev,
+			 "Failed to create xip_mode sysfs attribute: %d\n",
+			 ret);
+
+	if (dws->xip_mem) {
+		ret = device_create_file(&pdev->dev,
+					 &dev_attr_xip_continuous_mode);
+		if (ret)
+			dev_warn(&pdev->dev,
+				 "Failed to create xip_continuous_mode sysfs: %d\n",
+				 ret);
+
+		ret = device_create_file(&pdev->dev,
+					 &dev_attr_xip_prefetch_mode);
+		if (ret)
+			dev_warn(&pdev->dev,
+				 "Failed to create xip_prefetch_mode sysfs: %d\n",
+				 ret);
+	}
+	dev_info(&pdev->dev, "DW SSI G2 MMIO probed (mode=%s)\n",
+		 dws->use_xip ? "XIP" : "indirect");
 	return 0;
 
 err_pm:
@@ -168,10 +425,14 @@ 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);
 
+	device_remove_file(&pdev->dev, &dev_attr_xip_mode);
+	device_remove_file(&pdev->dev, &dev_attr_xip_continuous_mode);
+	device_remove_file(&pdev->dev, &dev_attr_xip_prefetch_mode);
 	spi_unregister_controller(ctlr);
 	dw_spi_g2_deinit(&dwsmmio->dws);
 	pm_runtime_disable(&pdev->dev);
 	reset_control_assert(dwsmmio->rstc);
+	dw_spi_g2_enable(&dwsmmio->dws, false);
 }
 
 static const struct of_device_id dw_spi_g2_of_match[] = {
diff --git a/drivers/spi/spi-dw-g2.h b/drivers/spi/spi-dw-g2.h
index 3091697238d7..162d23390298 100644
--- a/drivers/spi/spi-dw-g2.h
+++ b/drivers/spi/spi-dw-g2.h
@@ -3,12 +3,16 @@
 #ifndef _SPI_DW_G2_H
 #define _SPI_DW_G2_H
 
-#include <linux/spi/spi.h>
-#include <linux/io.h>
+#include <linux/bitfield.h>
+#include <linux/delay.h>
 #include <linux/device.h>
-#include <linux/irqreturn.h>
+#include <linux/io.h>
 #include <linux/iopoll.h>
+#include <linux/irqreturn.h>
+#include <linux/slab.h>
+#include <linux/spi/spi.h>
 #include <linux/spi/spi-mem.h>
+#include <linux/string.h>
 
 #ifdef CONFIG_DEBUG_FS
 #include <linux/debugfs.h>
@@ -24,7 +28,7 @@
 #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)
+	(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)
@@ -33,6 +37,84 @@
 #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)
 
+/*
+ * XIP (eXecute In Place) registers for direct memory-mapped access
+ */
+#define DW_SPI_G2_XIP_HEADER                    0x124
+#define DW_SPI_G2_XIP_SER                       0x128
+#define DW_SPI_G2_XIP_CNT_TIME_OUT              0x12C
+#define DW_SPI_G2_XIP_WR_SER                    0x134
+
+/*
+ * XIP_CNT_TIME_OUT fields
+ * XTOC[7:0]: timeout in hclk cycles to deselect target in continuous mode
+ *            if no AHB request arrives within this time. Max value 0xFF.
+ */
+#define DW_SPI_G2_XIP_XTOC_MASK                 GENMASK(7, 0)
+#define DW_SPI_G2_XIP_XTOC_DEFAULT              0xFFU
+
+/* Dedicated CS XIP register base offsets (per-CS stride = 0x10) */
+#define DW_SPI_G2_XIP_CTRL_BASE                 0x22C
+#define DW_SPI_G2_XIP_CTRL_STRIDE               0x10
+#define DW_SPI_G2_XIP_CTRL(cs) \
+	(DW_SPI_G2_XIP_CTRL_BASE + (cs) * DW_SPI_G2_XIP_CTRL_STRIDE)
+#define DW_SPI_G2_XIP_MODE_BITS(cs)             (DW_SPI_G2_XIP_CTRL(cs) + 0x04)
+#define DW_SPI_G2_XIP_INCR_INST(cs)             (DW_SPI_G2_XIP_CTRL(cs) + 0x08)
+#define DW_SPI_G2_XIP_WRAP_INST(cs)             (DW_SPI_G2_XIP_CTRL(cs) + 0x0C)
+
+/* XIP Write registers (per-CS stride = 0x0C: 3 regs × 4 bytes) */
+#define DW_SPI_G2_XIP_WR_CTRL_BASE              0x270
+#define DW_SPI_G2_XIP_WR_CTRL_STRIDE            0x0C
+#define DW_SPI_G2_XIP_WRITE_CTRL(cs) \
+	(DW_SPI_G2_XIP_WR_CTRL_BASE + (cs) * DW_SPI_G2_XIP_WR_CTRL_STRIDE)
+#define DW_SPI_G2_XIP_WRITE_INCR_INST(cs)       (DW_SPI_G2_XIP_WRITE_CTRL(cs) + 0x04)
+#define DW_SPI_G2_XIP_WRITE_WRAP_INST(cs)       (DW_SPI_G2_XIP_WRITE_CTRL(cs) + 0x08)
+
+/* XIP_CTRL fields (SSI_CSx_XIP_CTRL register) */
+#define DW_SPI_G2_XIP_CTRL_FRF_MASK             GENMASK(1, 0)
+#define DW_SPI_G2_XIP_CTRL_TRANS_TYPE_MASK      GENMASK(3, 2)
+#define DW_SPI_G2_XIP_CTRL_ADDR_L_MASK          GENMASK(7, 4)
+#define DW_SPI_G2_XIP_CTRL_INST_L_MASK          GENMASK(10, 9)
+#define DW_SPI_G2_XIP_CTRL_MD_BITS_EN           BIT(12)
+#define DW_SPI_G2_XIP_CTRL_WAIT_CYCLES_MASK     GENMASK(17, 13)
+#define DW_SPI_G2_XIP_CTRL_DFS_HC               BIT(18)
+#define DW_SPI_G2_XIP_CTRL_DDR_EN               BIT(19)
+#define DW_SPI_G2_XIP_CTRL_INST_DDR_EN          BIT(20)
+#define DW_SPI_G2_XIP_CTRL_RXDS_EN              BIT(21)
+#define DW_SPI_G2_XIP_CTRL_INST_EN              BIT(22)
+#define DW_SPI_G2_XIP_CTRL_CONT_XFER_EN         BIT(23)
+#define DW_SPI_G2_XIP_CTRL_HYPERBUS_EN          BIT(24)
+#define DW_SPI_G2_XIP_CTRL_RXDS_SIG_EN          BIT(25)
+#define DW_SPI_G2_XIP_CTRL_XIP_MBL_MASK         GENMASK(27, 26)
+#define DW_SPI_G2_XIP_CTRL_PREFETCH_EN          BIT(29)
+#define DW_SPI_G2_XIP_CTRL_RXDS_VL_EN           BIT(30)
+
+/* XIP_WRITE_CTRL fields (SSI_CSx_XIP_WRITE_CTRL register) */
+#define DW_SPI_G2_XIP_WR_CTRL_FRF_MASK          GENMASK(1, 0)
+#define DW_SPI_G2_XIP_WR_CTRL_TRANS_TYPE_MASK   GENMASK(3, 2)
+#define DW_SPI_G2_XIP_WR_CTRL_ADDR_L_MASK       GENMASK(7, 4)
+#define DW_SPI_G2_XIP_WR_CTRL_INST_L_MASK       GENMASK(9, 8)
+#define DW_SPI_G2_XIP_WR_CTRL_DDR_EN            BIT(10)
+#define DW_SPI_G2_XIP_WR_CTRL_INST_DDR_EN       BIT(11)
+#define DW_SPI_G2_XIP_WR_CTRL_HYPERBUS_EN       BIT(12)
+#define DW_SPI_G2_XIP_WR_CTRL_RXDS_SIG_EN       BIT(13)
+#define DW_SPI_G2_XIP_WR_CTRL_DM_EN             BIT(14)
+#define DW_SPI_G2_XIP_WR_CTRL_WAIT_CYCLES_MASK  GENMASK(20, 16)
+#define DW_SPI_G2_XIP_WR_CTRL_DFS_HC            BIT(21)
+
+/*
+ * NOR-XIP-write helper constants (used by dw_spi_g2_dirmap_write_nor_xip())
+ *
+ * The XIP_WRITE_CTRL register has no auto-WREN and no auto-WIP-poll
+ * support, so a NOR Page Program issued through the XIP-write engine
+ * must be wrapped per-byte with WREN + 1-byte XIP store + WIP poll.
+ * These opcodes are JEDEC standard and apply to all SPI-NOR devices.
+ */
+#define DW_SPI_G2_NOR_OP_WREN           0x06    /* Write Enable */
+#define DW_SPI_G2_NOR_OP_RDSR1          0x05    /* Read Status Register 1 */
+#define DW_SPI_G2_NOR_SR1_WIP           BIT(0)  /* Write-In-Progress in SR1 */
+#define DW_SPI_G2_NOR_WIP_TIMEOUT_MS    100     /* WIP poll timeout */
+
 #define DW_SPI_G2_SSIENR                0x4C
 #define DW_SPI_G2_SER                   0x54
 #define DW_SPI_G2_TXFTLR                0x58
@@ -49,6 +131,7 @@
 #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 */
@@ -76,7 +159,32 @@
 /* Clear all writable bits */
 #define DW_SPI_G2_ICR_ALL               0x0003AFFF
 
-#define DW_SPI_G2_RX_SAMPLE_DELAY       0x24
+/*
+ * Per-CS DDR drive edge registers.
+ * Controls which clock edge drives output data in DDR/DTR mode.
+ * CSL offsets: CS0=0x218, CS1=0x21C, CS2=0x220, CS3=0x224 (stride=4).
+ */
+#define DW_SPI_G2_DDR_DRIVE_EDGE_BASE   0x218
+#define DW_SPI_G2_DDR_DRIVE_EDGE(cs)   (DW_SPI_G2_DDR_DRIVE_EDGE_BASE + (cs) * 0x04)
+
+/*
+ * Per-CS RX sample delay registers.
+ * The register at 0x24 is DEDICATED_CS_RX_SAMPLE_DELAY_OFFSET (a pointer
+ * register, resetval = 0x200). The actual per-CS data registers start at
+ * 0x204 with a 4-byte stride.
+ */
+#define DW_SPI_G2_RX_SAMPLE_DLY_BASE    0x204
+#define DW_SPI_G2_RX_SAMPLE_DELAY(cs)  (DW_SPI_G2_RX_SAMPLE_DLY_BASE + (cs) * 0x04)
+
+
+/* CTRLR0 CLK_LOOP_EN (cleared for RX_SAMPLE_DELAY / RXDS modes) */
+#define DW_SPI_G2_CTRLR0_CLK_LOOP_EN    BIT(18)
+
+/* RX sampling modes (mutually exclusive) */
+enum dw_spi_g2_sampling_mode {
+	DW_SPI_G2_SAMPLING_RX_DELAY,    /* RX_SAMPLE_DELAY register */
+	DW_SPI_G2_SAMPLING_DATA_STROBE, /* RXDS/DQS from flash (DTR mode) */
+};
 
 /* CTRLR0 fields */
 #define DW_SPI_G2_CTRLR0_DFS_MASK     GENMASK(4, 0)
@@ -198,6 +306,9 @@ static inline u32 dw_spi_g2_addr_len(unsigned int addr_nbytes)
 /* Default FIFO depth */
 #define DW_SPI_G2_FIFO_LEN	256U
 
+/* Maximum chip selects supported */
+#define DW_SPI_G2_MAX_CS	4U
+
 /*
  * Maximum baud rate divisor value for BAUDR register.
  * BAUDR encoding: bit[0]=passthrough_en, bits[15:1]=SCKDV (divisor).
@@ -223,7 +334,7 @@ static inline u32 dw_spi_g2_addr_len(unsigned int addr_nbytes)
  * fifo_len entries (typically 256); we use a compile-time cap here and
  * check against the runtime fifo_len in is_reg_op().
  */
- #define DW_SPI_G2_REG_OP_BUF_SIZE	256U
+#define DW_SPI_G2_REG_OP_BUF_SIZE	256U
 
 struct dw_spi_g2_cfg {
 	u8 tmode;
@@ -252,7 +363,7 @@ struct dw_spi_g2 {
 	/* Current message transfer state info */
 	const void		*tx;
 	unsigned int		tx_len;
-	void		        *rx;
+	void			*rx;
 	unsigned int		rx_len;
 	u8			n_bytes;
 
@@ -260,9 +371,32 @@ struct dw_spi_g2 {
 	struct completion       mem_done;
 	int                     error;
 
+	/* XIP (Direct Mapping) support */
+	void __iomem		*xip_mem;
+	resource_size_t		xip_phys;
+	size_t			xip_len;
+	bool			use_xip;
+	bool			xip_continuous_mode;
+	bool			xip_prefetch_mode;
+
+	/* Per-CS RX sample delay (in SSI clock cycles) */
+	u8			rx_sample_dly[DW_SPI_G2_MAX_CS];
+	u8			cur_rx_sample_dly;
+	u32			def_rx_sample_dly_ns;
+
 	/* Flash type detection for timing workarounds */
 	bool			is_nand;
 
+
+	/* DMA support for FIFO/Indirect operations (External DMA) */
+	struct dma_chan		*tx_chan;
+	struct dma_chan		*rx_chan;
+	struct completion	tx_dma_complete;
+	struct completion	rx_dma_complete;
+	bool			use_dma_indirect;  /* DMA for FIFO operations */
+	bool			use_dma_read;      /* DMA for XIP (placeholder) */
+	u32			dma_caps;          /* DMA capability flags */
+
 #ifdef CONFIG_DEBUG_FS
 	struct dentry *debugfs;
 	struct debugfs_regset32 regset;
@@ -309,6 +443,9 @@ int dw_spi_g2_init(struct dw_spi_g2 *dws);
 
 void dw_spi_g2_deinit(struct dw_spi_g2 *dws);
 
+int dw_spi_g2_hw_init(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);
 
@@ -319,6 +456,17 @@ 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);
 
+/* XIP/Direct mapping support */
+int dw_spi_g2_dirmap_create(struct spi_mem_dirmap_desc *desc);
+ssize_t dw_spi_g2_dirmap_read(struct spi_mem_dirmap_desc *desc,
+			      u64 offs, size_t len, void *buf);
+ssize_t dw_spi_g2_dirmap_write(struct spi_mem_dirmap_desc *desc,
+			       u64 offs, size_t len, const void *buf);
+
+u32 dw_spi_g2_op_freq(struct dw_spi_g2 *dws,
+		      const struct spi_mem_op *op);
+void dw_spi_g2_program_baudr(struct dw_spi_g2 *dws, u32 freq);
+
 /* Helpers */
 static inline void dw_spi_g2_enable(struct dw_spi_g2 *dws, bool en)
 {
@@ -397,4 +545,8 @@ static inline void dw_spi_g2_transfer_end(struct dw_spi_g2 *dws)
 	dw_spi_g2_target_disable(dws, dws->cs);
 }
 
+/* Sampling mode configuration */
+void dw_spi_g2_set_sampling_mode(struct dw_spi_g2 *dws, u8 cs,
+				 enum dw_spi_g2_sampling_mode mode);
+
 #endif /* __SPI_DW_G2_H__ */
-- 
2.34.1


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

Thread overview: 11+ 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 ` [PATCH 2/6] spi: dw-g2: Add Synopsys DWC SSI v2.02a driver Prakriti Sharma
2026-11-19 10:28   ` sashiko-bot
2026-11-19 10:05 ` [PATCH 3/6] spi: dw-g2: Add indirect read and write Prakriti Sharma
2026-11-19 10:27   ` sashiko-bot
2026-11-19 10:05 ` [PATCH 4/6] spi: dw-g2: Add SPI-NAND support Prakriti Sharma
2026-11-19 10:25   ` sashiko-bot
2026-11-19 10:05 ` [PATCH 5/6] dt-bindings: spi: Document DWC SSI XIP properties Prakriti Sharma
2026-11-19 10:14   ` sashiko-bot
2026-11-19 10:05 ` Prakriti Sharma [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=20261119100513.433044-7-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