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
next prev parent 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