Devicetree
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Prakriti Sharma" <Prakriti.Sharma@synopsys.com>
Cc: devicetree@vger.kernel.org, robh@kernel.org, conor+dt@kernel.org
Subject: Re: [PATCH 4/6] spi: dw-g2: Add SPI-NAND support
Date: Thu, 19 Nov 2026 10:25:23 +0000	[thread overview]
Message-ID: <sashiko-outbox-222950@kernel.org> (raw)
In-Reply-To: <20261119100513.433044-5-prakriti@synopsys.com>

Thank you for your contribution! Sashiko AI review found 7 potential
issues to consider:
- [High] spi: dw-g2: dw_spi_g2_is_reg_op() routes multi-IO and DTR ops
  to 1-1-1 reg_op
- [High] spi: dw-g2: hidden CS-toggling chunks in
  dw_spi_g2_indirect_read() break NAND
- [High] spi: dw-g2: dw_spi_g2_reg_op() races SR_BUSY after CS assert
  and drops errors
- [High] spi: dw-g2: broken multi-IO/DTR writes, DTR wait cycles, and op
  validation
- [Medium] spi: dw-g2: dw_spi_g2_indirect_write() removes FIFO prefill
  before CS assert
- [Medium] spi: dw-g2: dws->is_nand is mutated unlocked and sticky
  across chip selects
- [Low] spi: dw-g2: unused write-only variable tx_entries in
  dw_spi_g2_indirect_read()
--

commit 9669d454b276956e6dd4740dc840ec3191c46b35
Author: Prakriti Sharma <Prakriti.Sharma@synopsys.com>

spi: dw-g2: Add SPI-NAND support

This commit updates the DW SSI G2 spi-mem implementation to handle SPI-NAND
devices by routing FIFO-sized operations through TR mode, chunking indirect
reads, and adding DTR support and a NAND CS settling delay.

> diff --git a/drivers/spi/spi-dw-g2-core.c b/drivers/spi/spi-dw-g2-core.c
> index c640d6a192600..a94d4a7870dfd 100644
> --- a/drivers/spi/spi-dw-g2-core.c
> +++ b/drivers/spi/spi-dw-g2-core.c
> @@ -262,9 +262,13 @@ static u32 dw_spi_g2_get_frf(const struct spi_mem_op *op)
>   * 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.
> + * TRANS_TYPE in SPI_CTRLR0 / XIP_CTRL controls only the instruction and
> + * address phases.  Data always uses the enhanced mode set by SPI_FRF in
> + * CTRLR0 (or FRF in XIP_CTRL).
> + *
> + *   TT0 (0x0): instruction standard, address standard  (1-1-x)
> + *   TT1 (0x1): instruction standard, address enhanced  (1-x-x)
> + *   TT2 (0x2): instruction enhanced, address enhanced  (x-x-x)
>   *
>   * Return: Transfer type value (0-2), or -EOPNOTSUPP for unsupported patterns
>   */
> @@ -272,29 +276,37 @@ 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 */
> +	if (!cmd_m && !addr_m)
> +		return DW_SPI_G2_TRANS_TYPE_TT0;	/* 1-1-x */
> +	if (!cmd_m && addr_m)
> +		return DW_SPI_G2_TRANS_TYPE_TT1;	/* 1-x-x */
> +	if (cmd_m && addr_m)
> +		return DW_SPI_G2_TRANS_TYPE_TT2;	/* x-x-x */
>  
>  	return -EOPNOTSUPP;
>  }
>  
>  /**
> - * dw_spi_g2_is_reg_op - Check if operation is a register read/write
> + * dw_spi_g2_is_reg_op - Check if operation fits in TR (transmit-receive) mode
> + * @dws: Driver state (provides runtime fifo_len)
>   * @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.
> + * Routes operations through TR mode when total transfer size (cmd + addr +
> + * dummy + data) fits within the FIFO. This avoids RO mode with SPI_CTRLR0
> + * (enhanced SPI framing) which some platforms don't fully support.
> + *
> + * Limit is min(fifo_len, compile-time buffer size) to stay within both
> + * the hardware FIFO and the stack-allocated buffers in reg_op().
>   */
> -static inline bool dw_spi_g2_is_reg_op(const struct spi_mem_op *op)
> +static inline bool dw_spi_g2_is_reg_op(struct dw_spi_g2 *dws,
> +				       const struct spi_mem_op *op)
>  {
> -	return !op->addr.nbytes && op->data.nbytes > 0 &&
> -	       op->data.nbytes <= DW_SPI_G2_REG_OP_MAX_DATA;
> +	u32 total = op->cmd.nbytes + op->addr.nbytes +
> +		    op->dummy.nbytes + op->data.nbytes;
> +	u32 limit = min_t(u32, dws->fifo_len, DW_SPI_G2_REG_OP_BUF_SIZE);
> +
> +	return op->data.nbytes > 0 && total <= limit;
>  }

[Severity: High]
Does dw_spi_g2_is_reg_op() route multi-IO, DTR, and 2-byte-opcode
operations up to 256 bytes into the 1-1-1 standard SPI path in
dw_spi_g2_reg_op()?

dw_spi_g2_reg_op_setup() hardcodes DW_SPI_G2_FRF_STANDARD and writes 0 to
DW_SPI_G2_SPI_CTRLR0, so any Dual, Quad, Octal, or DTR operation whose
total length fits in min(dws->fifo_len, 256) (such as a 64-byte SPI-NAND
OOB read using 1-1-4 Quad Read From Cache 0x6b) is clocked out on a single
data wire in STR mode.

In addition, dw_spi_g2_reg_op() serializes only one byte of op->cmd.opcode
and sets echo_bytes = 1 + op->addr.nbytes + op->dummy.nbytes (truncating
2-byte opcodes), drops op->dummy.nbytes on SPI_MEM_DATA_OUT, and clocks
dummy bytes as 1-bit data on SPI_MEM_DATA_IN.  Conversely, a standard
1-1-1 read larger than dws->fifo_len falls through to
dw_spi_g2_indirect_read(), which sets DW_SPI_G2_FRF_STANDARD (where
SPI_CTRLR0 enhanced framing is inactive) while writing chunk_op.addr.val
as a single DR0 entry.

> @@ -483,49 +495,132 @@ static void dw_spi_g2_reg_op_setup(struct dw_spi_g2 *dws,
>  
>  static int dw_spi_g2_reg_op(struct dw_spi_g2 *dws, const struct spi_mem_op *op)
>  {

[ ... ]

> +	/* Ensure all FIFO writes complete before CS assertion */
> +	wmb();
> +
> +	dw_spi_g2_cs_assert(dws, dws->cs);
> +
> +	/*
> +	 * CS settling delay for NAND flash:
> +	 *
> +	 * NAND flash requires a settling period after CS assertion before
> +	 * data transactions can begin reliably. This is a hardware timing requirement.
> +	 *
> +	 * This is specific to NAND flash behavior where CS-to-valid-data timing
> +	 * is more stringent than NOR flash. The delay applies to small
> +	 * register operations (reg_op path) which are commonly used for:
> +	 * - READID (0x9F)
> +	 * - GET_FEATURE (0x0F)
> +	 * - SET_FEATURE (0x1F)
> +	 * - READ_STATUS (0x0F with feature address)
> +	 *
> +	 * Note: Only applies to NAND (detected via DT "spi-nand" compatible)
> +	 * to avoid performance impact on NOR flash.
> +	 */
> +	if (dws->is_nand) {
> +		/* Force a register read to ensure CS assertion propagates */
> +		(void)dw_spi_g2_readl(dws->regs, DW_SPI_G2_SR);
> +		usleep_range(10, 20);
> +	}
> +
> +	dw_spi_g2_wait_idle(dws);
> +
> +	/* For TR mode reads, harvest RX FIFO after the burst completes */
> +	if (op->data.dir == SPI_MEM_DATA_IN) {
> +		u32 rxflr = dw_spi_g2_readl(dws->regs, DW_SPI_G2_RXFLR);
> +		u32 rx_got = min_t(u32, rxflr, tx_len);
> +
> +		/* Ensure RXFLR read completes before reading RX FIFO */
> +		rmb();
> +
> +		for (i = 0; i < rx_got; i++) {
> +			u8 val = dw_spi_g2_readl(dws->regs,
> +						 DW_SPI_G2_DR0) & 0xFF;
> +			if (i >= echo_bytes &&
> +			    (i - echo_bytes) < op->data.nbytes)
> +				((u8 *)op->data.buf.in)[i - echo_bytes] = val;
> +		}
> +
> +		if (rx_got < echo_bytes + op->data.nbytes) {
> +			dev_err(dws->dev,
> +				"reg_op RX short: got %u, need %u\n",
> +				rx_got, echo_bytes + op->data.nbytes);
> +			ret = -EIO;
> +		}
>  	}
>  
>  	dw_spi_g2_transfer_end(dws);

[Severity: High]
Can dw_spi_g2_wait_idle() return before DW_SPI_G2_SR_BUSY asserts after
dw_spi_g2_cs_assert()?

dw_spi_g2_wait_idle() only checks !(sr & DW_SPI_G2_SR_BUSY) without
checking DW_SPI_G2_SR_TFE.  In DWC SSI hardware, writing SER does not set
SR_BUSY until SER synchronizes into the ssi_clk domain.  When dws->is_nand
is false (such as on SPI-NOR), polling SR immediately after
dw_spi_g2_cs_assert() can observe SR_BUSY == 0 before shifting starts:
SPI_MEM_DATA_IN then reads RXFLR == 0 and fails with -EIO, while
SPI_MEM_DATA_OUT calls dw_spi_g2_transfer_end() and aborts the transfer
while the TX FIFO is still full.

Also, dw_spi_g2_wait_idle()'s return value is ignored, so a busy timeout
on SPI_MEM_DATA_OUT silently returns 0.

> @@ -615,14 +710,17 @@ static int dw_spi_g2_indirect_read_setup(struct dw_spi_g2 *dws,
>   * @dws: Driver state
>   * @op: SPI memory operation
>   *
> - * Reads data from flash using RO (receive-only) mode.
> + * Reads data from flash using RO (receive-only) mode with enhanced SPI
> + * framing via SPI_CTRLR0.
>   * Return: 0 on success, negative error code on failure
>   */
>  static int dw_spi_g2_indirect_read(struct dw_spi_g2 *dws,
>  				   const struct spi_mem_op *op)
>  {
> -	u32 tx_entries;
> +	struct spi_mem_op chunk_op;
>  	u8 dummy_buf = 0;
> +	u32 total, done = 0;
> +	u32 tx_entries;
>  	int ret;
>  
>  	if (!op->data.nbytes) {
> @@ -635,35 +733,67 @@ static int dw_spi_g2_indirect_read(struct dw_spi_g2 *dws,
>  		return -EINVAL;
>  	}
>  
> -	ret = dw_spi_g2_indirect_read_setup(dws, op);
> -	if (ret)
> -		return ret;
> +	total = op->data.nbytes;
> +	dev_dbg(dws->dev, "indirect_read: cmd=0x%02x addr=0x%llx len=%u\n",
> +		op->cmd.opcode, op->addr.val, total);
>  
> -	dw_spi_g2_target_enable(dws, dws->cs);
> -	dw_spi_g2_enable(dws, true);
> +	/*
> +	 * Split into chunks no larger than dws->fifo_len so the RX FIFO
> +	 * never overflows. Each iteration reprograms CTRLR1/NDF and
> +	 * re-issues cmd+addr with the column advanced. A single
> +	 * >fifo_len request leaves the controller idle (SR.BUSY=0,
> +	 * RXFLR=0) after the first FIFO worth of data, causing an
> +	 * RX timeout.
> +	 */
> +	chunk_op = *op;
> +
> +	while (done < total) {
> +		u32 chunk = min_t(u32, total - done, dws->fifo_len);
> +
> +		chunk_op.addr.val = op->addr.val + done;
> +		chunk_op.data.nbytes = chunk;
> +		chunk_op.data.buf.in = (u8 *)op->data.buf.in + done;
>  
> -	tx_entries = 0;
> +		ret = dw_spi_g2_indirect_read_setup(dws, &chunk_op);
> +		if (ret)
> +			return ret;
> +
> +		dw_spi_g2_target_enable(dws, dws->cs);
> +		dw_spi_g2_enable(dws, true);
>  
> -	/* Write instruction */
> -	dw_spi_g2_writel(dws->regs, DW_SPI_G2_DR0, op->cmd.opcode);
> -	tx_entries++;
> +		tx_entries = 0;
>  
> -	/* Write address as a packed 32-bit value (one FIFO entry) */
> -	if (op->addr.nbytes) {
> -		dw_spi_g2_writel(dws->regs, DW_SPI_G2_DR0, (u32)op->addr.val);
> +		/* Write instruction to DR0 */
> +		dw_spi_g2_writel(dws->regs, DW_SPI_G2_DR0,
> +				 chunk_op.cmd.opcode);
>  		tx_entries++;
> -	}
>  
> -	/* Assert CS - controller begins: sends TX FIFO, then receives */
> -	dw_spi_g2_cs_assert(dws, dws->cs);
> +		/*
> +		 * Write address as a single packed value.
> +		 * In enhanced SPI framing (RO mode with SPI_CTRLR0), the
> +		 * hardware extracts ADDR_L bits from this write.
> +		 */
> +		if (chunk_op.addr.nbytes) {
> +			dw_spi_g2_writel(dws->regs, DW_SPI_G2_DR0,
> +					 (u32)chunk_op.addr.val);
> +			tx_entries++;
> +		}

[Severity: Low]
tx_entries is assigned and incremented here, but never read, which triggers
a -Wunused-but-set-variable compiler warning.

>  
> -	/* Receive data via polling */
> -	ret = dw_spi_g2_xfer_fifo(dws, &dummy_buf, 0,
> -				  op->data.buf.in, op->data.nbytes);
> -	dw_spi_g2_transfer_end(dws);
> -	dw_spi_g2_controller_reset(dws);
> +		/* Assert CS - controller begins: sends TX FIFO, then receives */
> +		dw_spi_g2_cs_assert(dws, dws->cs);
>  
> -	return ret;
> +		/* Receive data via polling */
> +		ret = dw_spi_g2_xfer_fifo(dws, &dummy_buf, 0,
> +					  chunk_op.data.buf.in, chunk);
> +		dw_spi_g2_transfer_end(dws);
> +		dw_spi_g2_controller_reset(dws);
> +		if (ret)
> +			return ret;
> +
> +		done += chunk;
> +	}
> +
> +	return 0;
>  }

[Severity: High]
Won't splitting a single spi_mem_op across multiple CS assertions here while
raising DW_G2_MAX_CHUNK to 64 KB break SPI-NAND continuous reads?

In drivers/mtd/nand/spi/core.c, spinand_read_from_cache_op() relies on
adjust_op_size() clamping op->data.nbytes to the controller's single-CS
transfer limit so it can fall back to buffered page reads when a continuous
read cannot complete in one CS assertion.  On Winbond W25N01JW, continuous
read is enabled by default and uses a 1-byte dummy address (addr.nbytes = 1,
addr.val = 0) while streaming from column 0 for as long as CS stays low;
toggling CS every dws->fifo_len bytes aborts the continuous stream in the
flash and overflows the 1-byte dummy address once done >= 256.

If the controller cannot receive more than dws->fifo_len bytes in one CS
assertion, dw_spi_g2_adjust_mem_op_size() should clamp SPI_MEM_DATA_IN to
dws->fifo_len so the spi-mem and spinand callers advance the address and
manage CS boundaries themselves.

> @@ -676,20 +806,26 @@ static int dw_spi_g2_indirect_read(struct dw_spi_g2 *dws,
>   * @dws: Driver state
>   * @op: SPI memory operation
>   *
> - * Sets up TMOD=TO (transmit-only), standard SPI mode.
> + * Sets up TMOD=TO (transmit-only)
>   */
>  static void dw_spi_g2_indirect_write_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);
> +	u32 spictrlr0 = 0;
>  
>  	dw_spi_g2_controller_reset(dws);
>  	dw_spi_g2_target_disable(dws, dws->cs);
>  
> +	if (op->cmd.dtr)
> +		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;
> +
>  	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_SPI_CTRLR0(dws->cs), spictrlr0);
>  	dw_spi_g2_writel(dws->regs, DW_SPI_G2_TXFTLR, 0);
>  	dw_spi_g2_writel(dws->regs, DW_SPI_G2_RXFTLR, 0);
>  }

[ ... ]

> @@ -721,52 +861,36 @@ static int dw_spi_g2_indirect_write(struct dw_spi_g2 *dws,
>  		return -EINVAL;
>  	}
>  
> +	dev_dbg(dws->dev, "indirect_write: cmd=0x%02x addr=0x%llx len=%u\n",
> +		op->cmd.opcode, op->addr.val, op->data.nbytes);
> +
>  	dw_spi_g2_indirect_write_setup(dws, op);
>  
> -	/* Allocate and build TX buffer: [cmd][addr][data] */
>  	tx_buf = kzalloc(tx_total, GFP_KERNEL);
>  	if (!tx_buf)
>  		return -ENOMEM;
>  
>  	dw_spi_g2_fill_tx_buf(tx_buf, op, true);
>  
> -	/*
> -	 * Split enable sequence:
> -	 * Enable SSI (without CS), pre-fill TX FIFO, then assert CS.
> -	 * FIFO pointers are reset while SSIENR=0, so writes before
> -	 * enabling would be discarded.
> -	 */
>  	dw_spi_g2_target_enable(dws, dws->cs);
> -	dw_spi_g2_enable(dws, true);
> -
> -	/* Pre-fill FIFO to capacity or total size */
> -	prefill = min_t(u32, tx_total, dws->fifo_len);
> -	for (pos = 0; pos < prefill; pos++)
> -		dw_spi_g2_writel(dws->regs, DW_SPI_G2_DR0, tx_buf[pos]);
> -
> -	/* Assert CS - transfer starts */
>  	dw_spi_g2_cs_assert(dws, dws->cs);
> +	dw_spi_g2_enable(dws, true);
>  
> -	/* Refill FIFO with remaining bytes (if any) via polling */
> -	if (pos < tx_total) {
> -		int ret = dw_spi_g2_xfer_fifo(dws, &tx_buf[pos],
> -					      tx_total - pos, NULL, 0);
> -		if (ret) {
> -			dw_spi_g2_transfer_end(dws);
> -			dw_spi_g2_controller_reset(dws);
> -			kfree(tx_buf);
> -			return ret;
> -		}
> +	ret = dw_spi_g2_xfer_fifo(dws, tx_buf, tx_total, NULL, 0);

[Severity: Medium]
Can asserting CS and enabling SSI before pre-filling the TX FIFO cause a TX
FIFO underrun that deasserts CS mid-write?

With SER and SSIENR both active, DWC SSI starts shifting as soon as the
first byte is written to DR0 in dw_spi_g2_xfer_fifo(), and automatically
deasserts CS if the TX FIFO drains empty before the next byte arrives.
Because dw_spi_g2_xfer_fifo() runs in preemptible context and reads
DW_SPI_G2_SR before each byte write, an interrupt or scheduling delay after
the opcode byte can drain the 1-byte FIFO and toggle CS during a page
program.

> @@ -778,9 +902,46 @@ static int dw_spi_g2_indirect_write(struct dw_spi_g2 *dws,
>  static bool dw_spi_g2_supports_mem_ops(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);
> +	bool op_is_dtr =
> +		op->cmd.dtr || op->addr.dtr || op->dummy.dtr || op->data.dtr;
> +
> +	/*
> +	 * Detect NAND flash by checking device tree compatible string.
> +	 * This is used for VDK timing workarounds.
> +	 */
> +	if (spi->dev.of_node) {
> +		if (of_device_is_compatible(spi->dev.of_node, "spi-nand"))
> +			dws->is_nand = true;
> +	}

[Severity: Medium]
Isn't dws->is_nand controller-wide state that gets latched permanently across
all chip selects and modified without holding any controller lock?

supports_op() is called before spi_mem_access_start() acquires the bus
locks, and once any child node matches "spi-nand", dws->is_nand remains
true even when talking to a non-NAND device on another chip select.

> +
> +	if (op_is_dtr) {
> +		/*
> +		 * DTR requires enhanced SPI modes (Dual/Quad/Octal).
> +		 * Reject standard-width DTR since it has no practical use
> +		 * and the hardware doesn't support it meaningfully.
> +		 */
> +		if (op->data.nbytes && op->data.buswidth == 1)
> +			return false;
> +
> +		/*
> +		 * In DTR mode all phases must agree on DTR — reject
> +		 * mixed STR/DTR within a single operation.
> +		 */
> +		if (op->addr.nbytes && op->addr.dtr != op->cmd.dtr)
> +			return false;
> +		if (op->data.nbytes && op->data.dtr != op->cmd.dtr)
> +			return false;
> +	}
> +
>  	return spi_mem_default_supports_op(mem, op);
>  }

[Severity: High]
Does dw_spi_g2_supports_mem_ops() advertise multi-IO and DTR write and
command-only operations that the driver only transmits in 1-1-1 STR mode?

ctlr->mode_bits includes SPI_TX_DUAL, SPI_TX_QUAD, and SPI_TX_OCTAL, and
dw_spi_g2_mem_caps enables .dtr = true, so dw_spi_g2_supports_mem_ops()
accepts operations such as Winbond W25N01JW's 1-1-4 Program Load (0x32) or
8D-8D-8D writes.  However, dw_spi_g2_indirect_write_setup() and
dw_spi_g2_cmd_only_setup() both hardcode DW_SPI_G2_FRF_STANDARD (where the
DDR bits written to SPI_CTRLR0 are ignored) and leave INST_L and ADDR_L at
0, sending all bytes over a single wire.

There are two related DTR and buswidth issues in this path:

1. In dw_spi_g2_indirect_read_setup() and dw_spi_g2_exec_mem_op(),
   dummy_cycles is computed as (op->dummy.nbytes * 8) / op->dummy.buswidth
   without halving for DTR mode (later partially adjusted in commit
   "spi: dw-g2: Add XIP support"), programming twice the required wait
   cycles.

2. dw_spi_g2_supports_mem_ops() does not verify that op->dummy.dtr matches
   op->cmd.dtr, that cmd/addr buswidth > 1 is rejected when
   op->data.nbytes == 0, or that multi-line phase buswidths are supported by
   dw_spi_g2_get_tt() and the single CTRLR0.FRF field (for example,
   cmd.buswidth > 1 with addr.nbytes == 0 passes supports_op() and then
   fails in dw_spi_g2_get_tt() with -EOPNOTSUPP).

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261119100513.433044-1-prakriti@synopsys.com?part=4

  reply	other threads:[~2026-11-19 10:25 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 [this message]
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 ` [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=sashiko-outbox-222950@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=Prakriti.Sharma@synopsys.com \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=robh@kernel.org \
    --cc=sashiko-reviews@lists.linux.dev \
    /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