From: Mohammad Odeh <[email protected]>

Model the STM32L4x5 QuadSPI controller indirect read and write modes.
Wire its clock, interrupt, and SSI bus into the STM32L4x5 SoC.

Automatic polling, memory-mapped mode, and DMA are not implemented.

Signed-off-by: Mohammad Odeh <[email protected]>
---
 MAINTAINERS                        |   1 +
 hw/arm/Kconfig                     |   1 +
 hw/arm/stm32l4x5_soc.c             |  17 +
 hw/ssi/Kconfig                     |   4 +
 hw/ssi/meson.build                 |   1 +
 hw/ssi/stm32l4x5_quadspi.c         | 680 +++++++++++++++++++++++++++++
 include/hw/arm/stm32l4x5_soc.h     |   2 +
 include/hw/ssi/stm32l4x5_quadspi.h |  51 +++
 8 files changed, 757 insertions(+)
 create mode 100644 hw/ssi/stm32l4x5_quadspi.c
 create mode 100644 include/hw/ssi/stm32l4x5_quadspi.h

diff --git a/MAINTAINERS b/MAINTAINERS
index fa0c6d0c9b..7a820703f8 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1119,6 +1119,7 @@ F: hw/misc/stm32l4x5_exti.c
 F: hw/misc/stm32l4x5_syscfg.c
 F: hw/misc/stm32l4x5_rcc.c
 F: hw/gpio/stm32l4x5_gpio.c
+F: hw/ssi/stm32l4x5_quadspi.c
 F: include/hw/*/stm32l4x5_*.h
 F: tests/qtest/stm32l4x5*
 
diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig
index e9f796f718..94a01c412b 100644
--- a/hw/arm/Kconfig
+++ b/hw/arm/Kconfig
@@ -398,6 +398,7 @@ config STM32L4X5_SOC
     select STM32L4X5_RCC
     select STM32L4X5_GPIO
     select STM32L4X5_USART
+    select STM32L4X5_QUADSPI
 
 config XLNX_ZYNQMP_ARM
     bool
diff --git a/hw/arm/stm32l4x5_soc.c b/hw/arm/stm32l4x5_soc.c
index 39b8cdf97d..d91d18e88b 100644
--- a/hw/arm/stm32l4x5_soc.c
+++ b/hw/arm/stm32l4x5_soc.c
@@ -81,6 +81,9 @@ static const int exti_irq[NUM_EXTI_IRQ] = {
 #define RCC_BASE_ADDRESS 0x40021000
 #define RCC_IRQ 5
 
+#define QUADSPI_BASE_ADDRESS 0xa0001000
+#define QUADSPI_IRQ 71
+
 #define EXTI_USART1_IRQ 26
 #define EXTI_UART4_IRQ 29
 #define EXTI_LPUART1_IRQ 31
@@ -144,6 +147,8 @@ static void stm32l4x5_soc_initfn(Object *obj)
     }
     object_initialize_child(obj, "syscfg", &s->syscfg, TYPE_STM32L4X5_SYSCFG);
     object_initialize_child(obj, "rcc", &s->rcc, TYPE_STM32L4X5_RCC);
+    object_initialize_child(obj, "quadspi", &s->quadspi,
+                            TYPE_STM32L4X5_QUADSPI);
 
     for (unsigned i = 0; i < NUM_GPIOS; i++) {
         g_autofree char *name = g_strdup_printf("gpio%c", 'a' + i);
@@ -313,6 +318,18 @@ static void stm32l4x5_soc_realize(DeviceState *dev_soc, 
Error **errp)
     sysbus_mmio_map(busdev, 0, RCC_BASE_ADDRESS);
     sysbus_connect_irq(busdev, 0, qdev_get_gpio_in(armv7m, RCC_IRQ));
 
+    /* QuadSPI controller */
+    dev = DEVICE(&s->quadspi);
+    qdev_connect_clock_in(dev, "clk",
+        qdev_get_clock_out(DEVICE(&s->rcc), "qspi-out"));
+    busdev = SYS_BUS_DEVICE(dev);
+    if (!sysbus_realize(busdev, errp)) {
+        return;
+    }
+    sysbus_mmio_map(busdev, 0, QUADSPI_BASE_ADDRESS);
+    sysbus_connect_irq(busdev, 0,
+                       qdev_get_gpio_in(armv7m, QUADSPI_IRQ));
+
     /* USART devices */
     for (int i = 0; i < STM_NUM_USARTS; i++) {
         g_autofree char *name = g_strdup_printf("usart%d-out", i + 1);
diff --git a/hw/ssi/Kconfig b/hw/ssi/Kconfig
index d477d20e9b..1b79da6d90 100644
--- a/hw/ssi/Kconfig
+++ b/hw/ssi/Kconfig
@@ -21,6 +21,10 @@ config STM32F2XX_SPI
     bool
     select SSI
 
+config STM32L4X5_QUADSPI
+    bool
+    select SSI
+
 config BCM2835_SPI
     bool
     select SSI
diff --git a/hw/ssi/meson.build b/hw/ssi/meson.build
index f334e48e2f..ce9511b5df 100644
--- a/hw/ssi/meson.build
+++ b/hw/ssi/meson.build
@@ -6,6 +6,7 @@ system_ss.add(when: 'CONFIG_PL022', if_true: files('pl022.c'))
 system_ss.add(when: 'CONFIG_SIFIVE_SPI', if_true: files('sifive_spi.c'))
 system_ss.add(when: 'CONFIG_SSI', if_true: files('ssi.c'))
 system_ss.add(when: 'CONFIG_STM32F2XX_SPI', if_true: files('stm32f2xx_spi.c'))
+system_ss.add(when: 'CONFIG_STM32L4X5_QUADSPI', if_true: 
files('stm32l4x5_quadspi.c'))
 system_ss.add(when: 'CONFIG_XILINX_SPI', if_true: files('xilinx_spi.c'))
 system_ss.add(when: 'CONFIG_XILINX_SPIPS', if_true: files('xilinx_spips.c'))
 system_ss.add(when: 'CONFIG_XLNX_VERSAL', if_true: files('xlnx-versal-ospi.c'))
diff --git a/hw/ssi/stm32l4x5_quadspi.c b/hw/ssi/stm32l4x5_quadspi.c
new file mode 100644
index 0000000000..cb3e7eb665
--- /dev/null
+++ b/hw/ssi/stm32l4x5_quadspi.c
@@ -0,0 +1,680 @@
+/*
+ * STM32L4x5 QuadSPI controller
+ *
+ * Copyright (c) 2026 EXALT Technologies
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+/*
+ * The reference used is the STMicroelectronics RM0351 reference manual for
+ * STM32L47xxx, STM32L48xxx, STM32L49xxx and STM32L4Axxx MCUs.
+ */
+
+#include "qemu/osdep.h"
+#include "qemu/bitops.h"
+#include "qemu/log.h"
+#include "qapi/error.h"
+#include "hw/core/qdev-clock.h"
+#include "hw/core/irq.h"
+#include "hw/ssi/stm32l4x5_quadspi.h"
+#include "migration/vmstate.h"
+
+#define QUADSPI_MMIO_SIZE 0x400
+#define QUADSPI_FIFO_SIZE 16
+
+#define QUADSPI_CR    0x00
+#define QUADSPI_DCR   0x04
+#define QUADSPI_SR    0x08
+#define QUADSPI_FCR   0x0c
+#define QUADSPI_DLR   0x10
+#define QUADSPI_CCR   0x14
+#define QUADSPI_AR    0x18
+#define QUADSPI_ABR   0x1c
+#define QUADSPI_DR    0x20
+#define QUADSPI_PSMKR 0x24
+#define QUADSPI_PSMAR 0x28
+#define QUADSPI_PIR   0x2c
+#define QUADSPI_LPTR  0x30
+
+#define CR_EN       BIT(0)
+#define CR_ABORT    BIT(1)
+#define CR_DFM      BIT(6)
+#define CR_FTHRES_SHIFT 8
+#define CR_FTHRES   MAKE_64BIT_MASK(8, 4)
+#define CR_TEIE     BIT(16)
+#define CR_TCIE     BIT(17)
+#define CR_FTIE     BIT(18)
+#define CR_SMIE     BIT(19)
+#define CR_TOIE     BIT(20)
+
+#define SR_TEF      BIT(0)
+#define SR_TCF      BIT(1)
+#define SR_FTF      BIT(2)
+#define SR_SMF      BIT(3)
+#define SR_TOF      BIT(4)
+#define SR_BUSY     BIT(5)
+#define SR_FLEVEL   MAKE_64BIT_MASK(8, 5)
+#define SR_FLEVEL_SHIFT 8
+
+#define CCR_INSTRUCTION MAKE_64BIT_MASK(0, 8)
+#define CCR_IMODE       MAKE_64BIT_MASK(8, 2)
+#define CCR_ADMODE      MAKE_64BIT_MASK(10, 2)
+#define CCR_ADSIZE      MAKE_64BIT_MASK(12, 2)
+#define CCR_ABMODE      MAKE_64BIT_MASK(14, 2)
+#define CCR_ABSIZE      MAKE_64BIT_MASK(16, 2)
+#define CCR_DCYC        MAKE_64BIT_MASK(18, 5)
+#define CCR_DMODE       MAKE_64BIT_MASK(24, 2)
+#define CCR_FMODE       MAKE_64BIT_MASK(26, 2)
+#define CCR_SIOO        BIT(28)
+#define CCR_DDRM        BIT(31)
+
+#define CCR_IMODE_SHIFT 8
+#define CCR_ADMODE_SHIFT 10
+#define CCR_ADSIZE_SHIFT 12
+#define CCR_ABMODE_SHIFT 14
+#define CCR_ABSIZE_SHIFT 16
+#define CCR_DCYC_SHIFT 18
+#define CCR_DMODE_SHIFT 24
+#define CCR_FMODE_SHIFT 26
+
+enum QuadSpiFunctionalMode {
+    QUADSPI_INDIRECT_WRITE,
+    QUADSPI_INDIRECT_READ,
+    QUADSPI_AUTO_POLLING,
+    QUADSPI_MEMORY_MAPPED,
+};
+
+static unsigned int stm32l4x5_quadspi_mode_width(uint32_t mode)
+{
+    static const unsigned int widths[] = { 0, 1, 2, 4 };
+
+    return widths[mode & 3];
+}
+
+static unsigned int stm32l4x5_quadspi_fmode(Stm32l4x5QuadSpiState *s)
+{
+    return (s->ccr & CCR_FMODE) >> CCR_FMODE_SHIFT;
+}
+
+static void stm32l4x5_quadspi_update_irq(Stm32l4x5QuadSpiState *s)
+{
+    bool level = ((s->sr & SR_TEF) && (s->cr & CR_TEIE)) ||
+                 ((s->sr & SR_TCF) && (s->cr & CR_TCIE)) ||
+                 ((s->sr & SR_FTF) && (s->cr & CR_FTIE)) ||
+                 ((s->sr & SR_SMF) && (s->cr & CR_SMIE)) ||
+                 ((s->sr & SR_TOF) && (s->cr & CR_TOIE));
+
+    qemu_set_irq(s->irq, level);
+}
+
+static void stm32l4x5_quadspi_update_fifo(Stm32l4x5QuadSpiState *s)
+{
+    unsigned int level = fifo8_num_used(&s->fifo);
+    unsigned int threshold = ((s->cr & CR_FTHRES) >> CR_FTHRES_SHIFT) + 1;
+    unsigned int mode = stm32l4x5_quadspi_fmode(s);
+
+    s->sr &= ~(SR_FLEVEL | SR_FTF | SR_BUSY);
+    s->sr |= level << SR_FLEVEL_SHIFT;
+    if (s->transaction_active ||
+        (mode == QUADSPI_INDIRECT_READ && level)) {
+        s->sr |= SR_BUSY;
+    }
+    if (s->cr & CR_EN) {
+        if (mode == QUADSPI_INDIRECT_READ &&
+            (level >= threshold ||
+             (!s->remaining && !s->indefinite && level))) {
+            s->sr |= SR_FTF;
+        } else if (mode == QUADSPI_INDIRECT_WRITE &&
+                   fifo8_num_free(&s->fifo) >= threshold) {
+            s->sr |= SR_FTF;
+        }
+    }
+    stm32l4x5_quadspi_update_irq(s);
+}
+
+static void stm32l4x5_quadspi_select(Stm32l4x5QuadSpiState *s)
+{
+    if (!s->transaction_active) {
+        qemu_set_irq(s->cs, 0);
+        s->transaction_active = true;
+        s->sr |= SR_BUSY;
+    }
+}
+
+static void stm32l4x5_quadspi_deselect(Stm32l4x5QuadSpiState *s)
+{
+    if (s->transaction_active) {
+        qemu_set_irq(s->cs, 1);
+        s->transaction_active = false;
+    }
+    s->remaining = 0;
+    s->indefinite = false;
+    s->write_pending = false;
+}
+
+static void stm32l4x5_quadspi_transfer_value(Stm32l4x5QuadSpiState *s,
+                                              uint32_t value,
+                                              unsigned int count)
+{
+    for (int i = count - 1; i >= 0; i--) {
+        ssi_transfer(s->ssi, extract32(value, i * 8, 8));
+    }
+}
+
+static void stm32l4x5_quadspi_send_prefix(Stm32l4x5QuadSpiState *s)
+{
+    unsigned int imode = (s->ccr & CCR_IMODE) >> CCR_IMODE_SHIFT;
+    unsigned int admode = (s->ccr & CCR_ADMODE) >> CCR_ADMODE_SHIFT;
+    unsigned int abmode = (s->ccr & CCR_ABMODE) >> CCR_ABMODE_SHIFT;
+    unsigned int dmode = (s->ccr & CCR_DMODE) >> CCR_DMODE_SHIFT;
+    unsigned int dummy_cycles = (s->ccr & CCR_DCYC) >> CCR_DCYC_SHIFT;
+    unsigned int dummy_width;
+    unsigned int dummy_bytes;
+
+    stm32l4x5_quadspi_select(s);
+
+    if (imode) {
+        ssi_transfer(s->ssi, s->ccr & CCR_INSTRUCTION);
+    }
+    if (admode) {
+        unsigned int address_bytes =
+            ((s->ccr & CCR_ADSIZE) >> CCR_ADSIZE_SHIFT) + 1;
+
+        stm32l4x5_quadspi_transfer_value(s, s->ar, address_bytes);
+    }
+    if (abmode) {
+        unsigned int alternate_bytes =
+            ((s->ccr & CCR_ABSIZE) >> CCR_ABSIZE_SHIFT) + 1;
+
+        stm32l4x5_quadspi_transfer_value(s, s->abr, alternate_bytes);
+    }
+
+    dummy_width = stm32l4x5_quadspi_mode_width(admode ? admode : dmode);
+    dummy_bytes = DIV_ROUND_UP(dummy_cycles * dummy_width, 8);
+    for (unsigned int i = 0; i < dummy_bytes; i++) {
+        ssi_transfer(s->ssi, 0);
+    }
+}
+
+static void stm32l4x5_quadspi_complete(Stm32l4x5QuadSpiState *s)
+{
+    stm32l4x5_quadspi_deselect(s);
+    s->rx_stalled = false;
+    if (stm32l4x5_quadspi_fmode(s) == QUADSPI_INDIRECT_WRITE) {
+        fifo8_reset(&s->fifo);
+    }
+    s->sr |= SR_TCF;
+    stm32l4x5_quadspi_update_fifo(s);
+}
+
+static bool stm32l4x5_quadspi_prepare_data(Stm32l4x5QuadSpiState *s)
+{
+    unsigned int fsize = extract32(s->dcr, 16, 5);
+    uint64_t flash_size = 1ULL << (fsize + 1);
+    uint64_t address = (s->ccr & CCR_ADMODE) ? s->ar : 0;
+    bool has_data = s->ccr & CCR_DMODE;
+
+    fifo8_reset(&s->fifo);
+    s->rx_stalled = false;
+    s->write_pending = false;
+    s->indefinite = has_data && s->dlr == UINT32_MAX && fsize == 31;
+    s->remaining = has_data ? (uint64_t)s->dlr + 1 : 0;
+    s->sr &= ~SR_TCF;
+    if ((s->ccr & CCR_ADMODE) &&
+        (address >= flash_size ||
+         (has_data && s->dlr != UINT32_MAX &&
+          s->remaining > flash_size - address))) {
+        s->remaining = 0;
+        s->indefinite = false;
+        s->sr |= SR_TEF;
+        stm32l4x5_quadspi_update_fifo(s);
+        return false;
+    }
+    if (has_data && s->dlr == UINT32_MAX) {
+        s->remaining = s->indefinite ? 0 : flash_size - address;
+    }
+    stm32l4x5_quadspi_update_fifo(s);
+    return true;
+}
+
+static bool stm32l4x5_quadspi_indirect(Stm32l4x5QuadSpiState *s)
+{
+    if (stm32l4x5_quadspi_fmode(s) >= QUADSPI_AUTO_POLLING ||
+        (s->ccr & (CCR_SIOO | CCR_DDRM)) || (s->cr & CR_DFM)) {
+        qemu_log_mask(LOG_UNIMP,
+                      "%s: polling, mapped, SIOO, DDR, or dual flash mode\n",
+                      TYPE_STM32L4X5_QUADSPI);
+        return false;
+    }
+    return true;
+}
+
+static void stm32l4x5_quadspi_fill_fifo(Stm32l4x5QuadSpiState *s)
+{
+    if (!(s->cr & CR_EN) || !s->transaction_active) {
+        return;
+    }
+    /* After a full FIFO, reception resumes when FLEVEL is at most 11. */
+    if (s->rx_stalled && fifo8_num_used(&s->fifo) > 11) {
+        return;
+    }
+    s->rx_stalled = false;
+    while ((s->remaining || s->indefinite) && !fifo8_is_full(&s->fifo)) {
+        fifo8_push(&s->fifo, ssi_transfer(s->ssi, 0));
+        if (!s->indefinite) {
+            s->remaining--;
+        }
+    }
+    if (!s->remaining && !s->indefinite) {
+        stm32l4x5_quadspi_complete(s);
+    } else {
+        s->rx_stalled = true;
+        stm32l4x5_quadspi_update_fifo(s);
+    }
+}
+
+static void stm32l4x5_quadspi_start_read(Stm32l4x5QuadSpiState *s)
+{
+    if (!stm32l4x5_quadspi_prepare_data(s)) {
+        return;
+    }
+    stm32l4x5_quadspi_send_prefix(s);
+    stm32l4x5_quadspi_fill_fifo(s);
+}
+
+static void stm32l4x5_quadspi_execute_command(Stm32l4x5QuadSpiState *s)
+{
+    if (!stm32l4x5_quadspi_prepare_data(s)) {
+        return;
+    }
+    stm32l4x5_quadspi_send_prefix(s);
+    stm32l4x5_quadspi_complete(s);
+}
+
+static uint64_t stm32l4x5_quadspi_read_register(void *opaque, hwaddr addr,
+                                       unsigned int size)
+{
+    Stm32l4x5QuadSpiState *s = opaque;
+    uint32_t value = 0;
+
+    switch (addr) {
+    case QUADSPI_CR:
+        return s->cr;
+    case QUADSPI_DCR:
+        return s->dcr;
+    case QUADSPI_SR:
+        return s->sr;
+    case QUADSPI_FCR:
+        return 0;
+    case QUADSPI_DLR:
+        return s->dlr;
+    case QUADSPI_CCR:
+        return s->ccr;
+    case QUADSPI_AR:
+        return s->ar;
+    case QUADSPI_ABR:
+        return s->abr;
+    case QUADSPI_DR:
+        if (!(s->cr & CR_EN) ||
+            stm32l4x5_quadspi_fmode(s) != QUADSPI_INDIRECT_READ) {
+            return 0;
+        }
+        for (unsigned int i = 0; i < size && !fifo8_is_empty(&s->fifo); i++) {
+            value |= (uint32_t)fifo8_pop(&s->fifo) << (i * 8);
+        }
+        s->dr = value;
+        stm32l4x5_quadspi_fill_fifo(s);
+        stm32l4x5_quadspi_update_fifo(s);
+        return value;
+    case QUADSPI_PSMKR:
+        return s->psmkr;
+    case QUADSPI_PSMAR:
+        return s->psmar;
+    case QUADSPI_PIR:
+        return s->pir;
+    case QUADSPI_LPTR:
+        return s->lptr;
+    default:
+        qemu_log_mask(LOG_GUEST_ERROR,
+                      "%s: bad read offset 0x%" HWADDR_PRIx "\n",
+                      TYPE_STM32L4X5_QUADSPI, addr);
+        return 0;
+    }
+}
+
+static void stm32l4x5_quadspi_write_data(Stm32l4x5QuadSpiState *s,
+                                          uint32_t value,
+                                          unsigned int size)
+{
+    if (!(s->cr & CR_EN) ||
+        stm32l4x5_quadspi_fmode(s) != QUADSPI_INDIRECT_WRITE ||
+        (!s->write_pending && !s->remaining && !s->indefinite)) {
+        return;
+    }
+    if (s->write_pending) {
+        if (!stm32l4x5_quadspi_indirect(s) ||
+            !stm32l4x5_quadspi_prepare_data(s)) {
+            s->write_pending = false;
+            return;
+        }
+    }
+    if (fifo8_num_free(&s->fifo) < size) {
+        qemu_log_mask(LOG_GUEST_ERROR, "%s: write to full FIFO\n",
+                      TYPE_STM32L4X5_QUADSPI);
+        return;
+    }
+    for (unsigned int i = 0; i < size; i++) {
+        fifo8_push(&s->fifo, extract32(value, i * 8, 8));
+    }
+    s->dr = value;
+    if (!s->transaction_active) {
+        stm32l4x5_quadspi_send_prefix(s);
+    }
+
+    while ((s->remaining || s->indefinite) && !fifo8_is_empty(&s->fifo)) {
+        ssi_transfer(s->ssi, fifo8_pop(&s->fifo));
+        if (!s->indefinite) {
+            s->remaining--;
+        }
+    }
+
+    if (!s->remaining && !s->indefinite) {
+        stm32l4x5_quadspi_complete(s);
+    } else {
+        stm32l4x5_quadspi_update_fifo(s);
+    }
+}
+
+static void stm32l4x5_quadspi_abort(Stm32l4x5QuadSpiState *s)
+{
+    stm32l4x5_quadspi_deselect(s);
+    fifo8_reset(&s->fifo);
+    s->rx_stalled = false;
+    s->cr &= ~CR_ABORT;
+    s->sr |= SR_TCF;
+    stm32l4x5_quadspi_update_fifo(s);
+}
+
+static void stm32l4x5_quadspi_write_register(void *opaque, hwaddr addr,
+                                    uint64_t value, unsigned int size)
+{
+    Stm32l4x5QuadSpiState *s = opaque;
+
+    switch (addr) {
+    case QUADSPI_CR:
+        if (s->sr & SR_BUSY) {
+            uint32_t mutable = CR_EN | CR_ABORT | CR_TEIE | CR_TCIE |
+                               CR_FTIE | CR_SMIE | CR_TOIE;
+            value = (s->cr & ~mutable) | (value & mutable);
+        }
+        s->cr = value;
+        if (s->cr & CR_ABORT) {
+            stm32l4x5_quadspi_abort(s);
+        } else {
+            if (!(s->cr & CR_EN)) {
+                /* Disabling is not a reset or a transfer-complete event. */
+                stm32l4x5_quadspi_deselect(s);
+                fifo8_reset(&s->fifo);
+                s->rx_stalled = false;
+            }
+            stm32l4x5_quadspi_update_fifo(s);
+        }
+        return;
+    case QUADSPI_DCR:
+        s->dcr = value;
+        return;
+    case QUADSPI_SR:
+        return;
+    case QUADSPI_FCR:
+        s->sr &= ~(value & (SR_TEF | SR_TCF | SR_SMF | SR_TOF));
+        stm32l4x5_quadspi_update_irq(s);
+        return;
+    case QUADSPI_DLR:
+        s->dlr = value;
+        return;
+    case QUADSPI_CCR:
+        s->ccr = value;
+        s->write_pending = false;
+        if (!(s->cr & CR_EN) || !stm32l4x5_quadspi_indirect(s)) {
+            return;
+        }
+        if (((s->ccr & CCR_DMODE) == 0) &&
+            ((s->ccr & CCR_ADMODE) == 0) &&
+            ((s->ccr & CCR_IMODE) != 0)) {
+            stm32l4x5_quadspi_execute_command(s);
+        } else if ((s->ccr & CCR_DMODE) &&
+                   stm32l4x5_quadspi_fmode(s) == QUADSPI_INDIRECT_WRITE) {
+            s->write_pending = true;
+            stm32l4x5_quadspi_update_fifo(s);
+        } else if ((s->ccr & CCR_DMODE) &&
+                   !(s->ccr & CCR_ADMODE) &&
+                   stm32l4x5_quadspi_fmode(s) == QUADSPI_INDIRECT_READ) {
+            stm32l4x5_quadspi_start_read(s);
+        }
+        return;
+    case QUADSPI_AR:
+        s->ar = value;
+        if (!(s->cr & CR_EN) || !stm32l4x5_quadspi_indirect(s)) {
+            return;
+        }
+        if ((s->ccr & CCR_DMODE) && (s->ccr & CCR_ADMODE) &&
+            stm32l4x5_quadspi_fmode(s) == QUADSPI_INDIRECT_READ) {
+            stm32l4x5_quadspi_start_read(s);
+        } else if (((s->ccr & CCR_DMODE) == 0) &&
+                   ((s->ccr & CCR_ADMODE) != 0)) {
+            stm32l4x5_quadspi_execute_command(s);
+        }
+        return;
+    case QUADSPI_ABR:
+        s->abr = value;
+        return;
+    case QUADSPI_DR:
+        stm32l4x5_quadspi_write_data(s, value, size);
+        return;
+    case QUADSPI_PSMKR:
+        s->psmkr = value;
+        return;
+    case QUADSPI_PSMAR:
+        s->psmar = value;
+        return;
+    case QUADSPI_PIR:
+        s->pir = value;
+        return;
+    case QUADSPI_LPTR:
+        s->lptr = value;
+        return;
+    default:
+        qemu_log_mask(LOG_GUEST_ERROR,
+                      "%s: bad write offset 0x%" HWADDR_PRIx "\n",
+                      TYPE_STM32L4X5_QUADSPI, addr);
+    }
+}
+
+static uint64_t stm32l4x5_quadspi_read(void *opaque, hwaddr addr,
+                                      unsigned int size)
+{
+    uint64_t value;
+
+    if ((addr & ~3ULL) == QUADSPI_DR) {
+        /* DR access size determines the number of FIFO bytes consumed. */
+        return stm32l4x5_quadspi_read_register(opaque, addr, size);
+    }
+    value = stm32l4x5_quadspi_read_register(opaque, addr & ~3ULL, 4);
+    return extract32(value, (addr & 3) * 8, size * 8);
+}
+
+static void stm32l4x5_quadspi_write(void *opaque, hwaddr addr,
+                                  uint64_t value, unsigned int size)
+{
+    Stm32l4x5QuadSpiState *s = opaque;
+    unsigned int shift = (addr & 3) * 8;
+    hwaddr reg = addr & ~3ULL;
+
+    if ((s->sr & SR_BUSY) && reg != QUADSPI_CR &&
+        reg != QUADSPI_FCR && reg != QUADSPI_SR && reg != QUADSPI_DR) {
+        qemu_log_mask(LOG_GUEST_ERROR,
+                      "%s: configuration write while busy\n",
+                      TYPE_STM32L4X5_QUADSPI);
+        return;
+    }
+    if (reg == QUADSPI_FCR) {
+        value <<= shift;
+    } else if (reg != QUADSPI_DR && size != 4) {
+        uint32_t mask = MAKE_64BIT_MASK(shift, size * 8);
+        uint32_t old = stm32l4x5_quadspi_read_register(s, reg, 4);
+
+        value = (old & ~mask) | ((value << shift) & mask);
+    }
+    stm32l4x5_quadspi_write_register(s, reg, value, size);
+}
+
+static bool stm32l4x5_quadspi_accepts(void *opaque, hwaddr addr,
+                                   unsigned int size, bool is_write,
+                                   MemTxAttrs attrs)
+{
+    return (size == 1 || size == 2 || size == 4) &&
+           ((addr & ~3ULL) != QUADSPI_DR || addr == QUADSPI_DR);
+}
+
+static const MemoryRegionOps stm32l4x5_quadspi_ops = {
+    .read = stm32l4x5_quadspi_read,
+    .write = stm32l4x5_quadspi_write,
+    .endianness = DEVICE_LITTLE_ENDIAN,
+    .impl.min_access_size = 1,
+    .impl.max_access_size = 4,
+    .valid.min_access_size = 1,
+    .valid.max_access_size = 4,
+    .valid.unaligned = false,
+    .valid.accepts = stm32l4x5_quadspi_accepts,
+};
+
+static void stm32l4x5_quadspi_hold_reset(Object *obj, ResetType type)
+{
+    Stm32l4x5QuadSpiState *s = STM32L4X5_QUADSPI(obj);
+
+    s->cr = 0;
+    s->dcr = 0;
+    s->sr = 0;
+    s->dlr = 0;
+    s->ccr = 0;
+    s->ar = 0;
+    s->abr = 0;
+    s->dr = 0;
+    s->psmkr = 0;
+    s->psmar = 0;
+    s->pir = 0;
+    s->lptr = 0;
+    s->remaining = 0;
+    s->transaction_active = false;
+    s->rx_stalled = false;
+    s->indefinite = false;
+    s->write_pending = false;
+    fifo8_reset(&s->fifo);
+    qemu_set_irq(s->cs, 1);
+    qemu_irq_lower(s->irq);
+}
+
+static void stm32l4x5_quadspi_init(Object *obj)
+{
+    Stm32l4x5QuadSpiState *s = STM32L4X5_QUADSPI(obj);
+    DeviceState *dev = DEVICE(obj);
+
+    fifo8_create(&s->fifo, QUADSPI_FIFO_SIZE);
+    memory_region_init_io(&s->mmio, obj, &stm32l4x5_quadspi_ops, s,
+                          TYPE_STM32L4X5_QUADSPI, QUADSPI_MMIO_SIZE);
+    sysbus_init_mmio(SYS_BUS_DEVICE(obj), &s->mmio);
+    sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irq);
+    qdev_init_gpio_out_named(dev, &s->cs, "cs", 1);
+    s->ssi = ssi_create_bus(dev, "ssi");
+    s->clk = qdev_init_clock_in(dev, "clk", NULL, s, 0);
+}
+
+static void stm32l4x5_quadspi_finalize(Object *obj)
+{
+    Stm32l4x5QuadSpiState *s = STM32L4X5_QUADSPI(obj);
+
+    fifo8_destroy(&s->fifo);
+}
+
+static void stm32l4x5_quadspi_realize(DeviceState *dev, Error **errp)
+{
+    Stm32l4x5QuadSpiState *s = STM32L4X5_QUADSPI(dev);
+
+    if (!clock_has_source(s->clk)) {
+        error_setg(errp, "%s: clk input must be connected",
+                   TYPE_STM32L4X5_QUADSPI);
+    }
+}
+
+static int stm32l4x5_quadspi_post_load(void *opaque, int version_id)
+{
+    Stm32l4x5QuadSpiState *s = opaque;
+
+    if (s->fifo.head >= QUADSPI_FIFO_SIZE ||
+        fifo8_num_used(&s->fifo) > QUADSPI_FIFO_SIZE) {
+        return -EINVAL;
+    }
+    if ((s->transaction_active && !(s->cr & CR_EN)) ||
+        (s->indefinite && s->remaining)) {
+        return -EINVAL;
+    }
+    qemu_set_irq(s->cs, !s->transaction_active);
+    stm32l4x5_quadspi_update_fifo(s);
+    return 0;
+}
+
+static const VMStateDescription vmstate_stm32l4x5_quadspi = {
+    .name = TYPE_STM32L4X5_QUADSPI,
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .post_load = stm32l4x5_quadspi_post_load,
+    .fields = (const VMStateField[]) {
+        VMSTATE_UINT32(cr, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(dcr, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(sr, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(dlr, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(ccr, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(ar, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(abr, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(dr, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(psmkr, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(psmar, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(pir, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT32(lptr, Stm32l4x5QuadSpiState),
+        VMSTATE_UINT64(remaining, Stm32l4x5QuadSpiState),
+        VMSTATE_BOOL(transaction_active, Stm32l4x5QuadSpiState),
+        VMSTATE_FIFO8(fifo, Stm32l4x5QuadSpiState),
+        VMSTATE_BOOL(rx_stalled, Stm32l4x5QuadSpiState),
+        VMSTATE_BOOL(indefinite, Stm32l4x5QuadSpiState),
+        VMSTATE_BOOL(write_pending, Stm32l4x5QuadSpiState),
+        VMSTATE_CLOCK(clk, Stm32l4x5QuadSpiState),
+        VMSTATE_END_OF_LIST()
+    },
+};
+
+static void stm32l4x5_quadspi_class_init(ObjectClass *klass, const void *data)
+{
+    DeviceClass *dc = DEVICE_CLASS(klass);
+    ResettableClass *rc = RESETTABLE_CLASS(klass);
+
+    dc->realize = stm32l4x5_quadspi_realize;
+    dc->vmsd = &vmstate_stm32l4x5_quadspi;
+    rc->phases.hold = stm32l4x5_quadspi_hold_reset;
+}
+
+static const TypeInfo stm32l4x5_quadspi_info = {
+    .name = TYPE_STM32L4X5_QUADSPI,
+    .parent = TYPE_SYS_BUS_DEVICE,
+    .instance_size = sizeof(Stm32l4x5QuadSpiState),
+    .instance_init = stm32l4x5_quadspi_init,
+    .instance_finalize = stm32l4x5_quadspi_finalize,
+    .class_init = stm32l4x5_quadspi_class_init,
+};
+
+static void stm32l4x5_quadspi_register_types(void)
+{
+    type_register_static(&stm32l4x5_quadspi_info);
+}
+
+type_init(stm32l4x5_quadspi_register_types)
diff --git a/include/hw/arm/stm32l4x5_soc.h b/include/hw/arm/stm32l4x5_soc.h
index 9c3d662bca..5b5e817ee7 100644
--- a/include/hw/arm/stm32l4x5_soc.h
+++ b/include/hw/arm/stm32l4x5_soc.h
@@ -32,6 +32,7 @@
 #include "hw/misc/stm32l4x5_rcc.h"
 #include "hw/gpio/stm32l4x5_gpio.h"
 #include "hw/char/stm32l4x5_usart.h"
+#include "hw/ssi/stm32l4x5_quadspi.h"
 #include "qom/object.h"
 
 #define TYPE_STM32L4X5_SOC "stm32l4x5-soc"
@@ -56,6 +57,7 @@ struct Stm32l4x5SocState {
     Stm32l4x5RccState rcc;
     Stm32l4x5GpioState gpio[NUM_GPIOS];
     Stm32l4x5UsartBaseState usart[STM_NUM_USARTS];
+    Stm32l4x5QuadSpiState quadspi;
     Stm32l4x5UsartBaseState uart[STM_NUM_UARTS];
     Stm32l4x5UsartBaseState lpuart;
 
diff --git a/include/hw/ssi/stm32l4x5_quadspi.h 
b/include/hw/ssi/stm32l4x5_quadspi.h
new file mode 100644
index 0000000000..e9882dd996
--- /dev/null
+++ b/include/hw/ssi/stm32l4x5_quadspi.h
@@ -0,0 +1,51 @@
+/*
+ * STM32L4x5 QuadSPI controller
+ *
+ * Copyright (c) 2026 EXALT Technologies
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef HW_STM32L4X5_QUADSPI_H
+#define HW_STM32L4X5_QUADSPI_H
+
+#include "hw/core/clock.h"
+#include "hw/core/sysbus.h"
+#include "hw/ssi/ssi.h"
+#include "qemu/fifo8.h"
+#include "qom/object.h"
+
+#define TYPE_STM32L4X5_QUADSPI "stm32l4x5-quadspi"
+OBJECT_DECLARE_SIMPLE_TYPE(Stm32l4x5QuadSpiState, STM32L4X5_QUADSPI)
+
+struct Stm32l4x5QuadSpiState {
+    SysBusDevice parent_obj;
+
+    MemoryRegion mmio;
+    Clock *clk;
+    qemu_irq irq;
+    qemu_irq cs;
+    SSIBus *ssi;
+
+    uint32_t cr;
+    uint32_t dcr;
+    uint32_t sr;
+    uint32_t dlr;
+    uint32_t ccr;
+    uint32_t ar;
+    uint32_t abr;
+    uint32_t dr;
+    uint32_t psmkr;
+    uint32_t psmar;
+    uint32_t pir;
+    uint32_t lptr;
+
+    Fifo8 fifo;
+    uint64_t remaining;
+    bool transaction_active;
+    bool rx_stalled;
+    bool indefinite;
+    bool write_pending;
+};
+
+#endif /* HW_STM32L4X5_QUADSPI_H */
-- 
2.49.1


Reply via email to