[ot] hw/riscv: ot_earlgrey: create flash & bus for spi passthrough mode

This commit creates a new internal SPI bus and CS GPIO for
`ot-spi_device` to communicate with a downstream flash device in
passthrough mode. This commits adds no passthrough functionality yet,
just command line functionality.

This is done by creating and adding a new flash device with an
associated drive to the board, similar to how the other flash devices
are added. The next available drive bus index was 3.

The downstream flash for passthrough mode can be created like this on
the command line:

- `-global ot-earlgrey-board.spiflash_passthrough=<type>`, where `type`
is a type of flash device from the M25P80 family, e.g `w25q256` (see
`hw/block/m25p80.c` for a list)

- `-drive if=mtd,file=<file>,format=raw,bus=3` to assign backing storage
to the flash. Bus 3 indicates the SPI flash for OT SPI Device
passthrough mode.

Signed-off-by: Alice Ziuziakowska <[email protected]>

Author: ziuziakowska

hw/opentitan/Kconfig

@@ -180,6 +180,7 @@ config OT_SOCDBG_CTRL
 
 config OT_SPI_DEVICE
     bool
+    select SSI
 
 config OT_SPI_HOST
     bool

hw/opentitan/ot_spi_device.c

@@ -41,6 +41,7 @@
 #include "hw/registerfields.h"
 #include "hw/riscv/ibex_common.h"
 #include "hw/riscv/ibex_irq.h"
+#include "hw/ssi/ssi.h"
 #include "trace.h"
 
 #define PARAM_SRAM_DEPTH         1024u
@@ -438,6 +439,9 @@ struct OtSPIDeviceState {
     SpiDeviceBus bus;
     SpiDeviceFlash flash;
 
+    SSIBus *spi; /* SPI Bus for downstream flash in passthrough mode */
+    qemu_irq spi_cs; /* CS signal for downstream flash in passthrough mode */
+
     uint32_t *spi_regs; /* Registers */
     uint32_t *tpm_regs; /* Registers */
     uint32_t *sram; /* SRAM (DPRAM on EG, E/I on DJ) */
@@ -2176,6 +2180,9 @@ static void ot_spi_device_realize(DeviceState *dev, Error **errp)
 
     g_assert(s->ot_id);
 
+    s->spi = ssi_create_bus(DEVICE(s), "passthrough");
+    qdev_init_gpio_out_named(DEVICE(s), &s->spi_cs, SSI_GPIO_CS, 1);
+
     qemu_chr_fe_set_handlers(&s->chr, &ot_spi_device_chr_can_receive,
                              &ot_spi_device_chr_receive,
                              &ot_spi_device_chr_event_hander,

hw/riscv/ot_earlgrey.c

@@ -179,8 +179,9 @@ enum OtEgResetRequest {
 enum OtEgMtdBus {
     OT_EG_MTD_SPI0,
     OT_EG_MTD_SPI1,
-    OT_EG_MTD_SPI_COUNT,
-    OT_EG_MTD_EFLASH = OT_EG_MTD_SPI_COUNT,
+    OT_EG_MTD_GENERIC_SPI_COUNT,
+    OT_EG_MTD_EFLASH = OT_EG_MTD_GENERIC_SPI_COUNT,
+    OT_EG_MTD_SPI_PASSTHRU,
 };
 
 /* "Parallel" flash buses */
@@ -192,6 +193,7 @@ enum OtEGBoardDevice {
     OT_EG_BOARD_DEV_SOC,
     OT_EG_BOARD_DEV_FLASH0,
     OT_EG_BOARD_DEV_FLASH1,
+    OT_EG_BOARD_DEV_FLASH_PASSTHRU,
     OT_EG_BOARD_DEV_COUNT,
 };
 
@@ -1481,7 +1483,13 @@ struct OtEGBoardState {
     DeviceState **devices;
 
     /* optional SPI data flash (type of device) */
-    char *spiflash[OT_EG_MTD_SPI_COUNT];
+    char *spiflash[OT_EG_MTD_GENERIC_SPI_COUNT];
+
+    /*
+     * optional downstream SPI data flash for passthrough mode
+     * in OT SPI Device (type of device)
+     */
+    char *spiflash_passthru;
 };
 
 struct OtEGMachineState {
@@ -1834,6 +1842,16 @@ static void ot_eg_board_set_spiflash1(Object *obj, const char *value,
     board->spiflash[OT_EG_MTD_SPI1] = g_strdup(value);
 }
 
+static void ot_eg_board_set_spiflash_passthrough(Object *obj, const char *value,
+                                                 Error **errp)
+{
+    OtEGBoardState *board = RISCV_OT_EG_BOARD(obj);
+    (void)errp;
+
+    g_free(board->spiflash_passthru);
+    board->spiflash_passthru = g_strdup(value);
+}
+
 static void ot_eg_board_child_foreach(Object *obj, ResettableChildCallback cb,
                                       void *opaque, ResetType type)
 {
@@ -1857,7 +1875,7 @@ static void ot_eg_board_realize(DeviceState *dev, Error **errp)
     BusState *bus = sysbus_get_default();
     qdev_realize_and_unref(soc, bus, &error_fatal);
 
-    for (unsigned fix = 0; fix < OT_EG_MTD_SPI_COUNT; fix++) {
+    for (unsigned fix = 0; fix < OT_EG_MTD_GENERIC_SPI_COUNT; fix++) {
         const char *flash_type = board->spiflash[OT_EG_MTD_SPI0 + fix];
         /*
          * skip this flash slot if no device type has been defined on the QEMU
@@ -1914,6 +1932,43 @@ static void ot_eg_board_realize(DeviceState *dev, Error **errp)
         g_free(flashname);
         g_free(busname);
     }
+
+    /* create downstream flash for OT SPI Device passthrough mode */
+    if (board->spiflash_passthru) {
+        DeviceState *pt_flash = qdev_new(board->spiflash_passthru);
+        if (!object_dynamic_cast(OBJECT(pt_flash), TYPE_M25P80)) {
+            error_setg(errp, "%s is not a SPI dataflash device",
+                       board->spiflash_passthru);
+        }
+
+        /*
+         * OT SPI Device is the SPI host, with a "passthrough" bus for the
+         * downstream flash device.
+         */
+        DeviceState *spidevice =
+            RISCV_OT_EG_SOC(soc)->devices[OT_EG_SOC_DEV_SPI_DEVICE];
+        BusState *spibus = qdev_get_child_bus(spidevice, "passthrough");
+        g_assert(spibus);
+
+        /* assign drive to the flash device if given */
+        DriveInfo *dinfo = drive_get(IF_MTD, OT_EG_MTD_SPI_PASSTHRU, 0);
+        if (dinfo) {
+            qdev_prop_set_drive_err(DEVICE(pt_flash), "drive",
+                                    blk_by_legacy_dinfo(dinfo), &error_fatal);
+        }
+
+        board->devices[OT_EG_BOARD_DEV_FLASH_PASSTHRU] = pt_flash;
+
+        /* the flash device is a child of the board */
+        object_property_add_child(OBJECT(board), "passthrough",
+                                  OBJECT(pt_flash));
+        /* connect the flash as a peripheral of the passthrough bus */
+        ssi_realize_and_unref(pt_flash, SSI_BUS(spibus), errp);
+
+        /* connect the CS line */
+        qemu_irq cs = qdev_get_gpio_in_named(pt_flash, SSI_GPIO_CS, 0);
+        qdev_connect_gpio_out_named(spidevice, SSI_GPIO_CS, 0, cs);
+    }
 }
 
 static void ot_eg_board_init(Object *obj)
@@ -1924,6 +1979,11 @@ static void ot_eg_board_init(Object *obj)
     object_property_add_str(obj, "spiflash1", NULL, &ot_eg_board_set_spiflash1);
     object_property_set_description(obj, "spiflash1",
                                     "SPI dataflash on SPI1 bus");
+    object_property_add_str(obj, "spiflash_passthrough", NULL,
+                            &ot_eg_board_set_spiflash_passthrough);
+    object_property_set_description(
+        obj, "spiflash_passthrough",
+        "downstream SPI dataflash for OT SPI Device in Passthrough Mode");
 
     OtEGBoardState *s = RISCV_OT_EG_BOARD(obj);