From ef7357d0328c5884dde8c8843b71704ab4c7235f Mon Sep 17 00:00:00 2001 From: TOKITA Hiroshi Date: Thu, 5 Jun 2025 17:02:01 +0900 Subject: [PATCH 1/5] drivers: entropy: virtio: Unify the notation to `VIRTIO` Since `VirtIO` is not the official notation, unify the name to `VIRTIO`. In the text, `Virtio` and `virtio` can also be used depending on the context. Signed-off-by: TOKITA Hiroshi --- drivers/entropy/Kconfig.virtio | 4 ++-- drivers/entropy/entropy_virtio.c | 2 +- dts/bindings/rng/virtio,device4.yaml | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/drivers/entropy/Kconfig.virtio b/drivers/entropy/Kconfig.virtio index eb741c3974253..df9cf62823f35 100644 --- a/drivers/entropy/Kconfig.virtio +++ b/drivers/entropy/Kconfig.virtio @@ -2,10 +2,10 @@ # SPDX-License-Identifier: Apache-2.0 config ENTROPY_VIRTIO - bool "Driver for VirtIO Entropy device" + bool "Driver for VIRTIO Entropy device" depends on DT_HAS_VIRTIO_DEVICE4_ENABLED depends on VIRTIO select ENTROPY_HAS_DRIVER default y help - Enable driver for the VirtIO Entropy device. + Enable driver for the VIRTIO Entropy device. diff --git a/drivers/entropy/entropy_virtio.c b/drivers/entropy/entropy_virtio.c index 7e8938d24c9fb..8e21db662bf2d 100644 --- a/drivers/entropy/entropy_virtio.c +++ b/drivers/entropy/entropy_virtio.c @@ -98,7 +98,7 @@ static int entropy_virtio_init(const struct device *dev) k_sem_init(&data->sem, 0, 1); - LOG_DBG("VirtIO entropy driver initialized"); + LOG_DBG("virtio entropy driver initialized"); return 0; } diff --git a/dts/bindings/rng/virtio,device4.yaml b/dts/bindings/rng/virtio,device4.yaml index 318f88a527464..fc08d1632891d 100644 --- a/dts/bindings/rng/virtio,device4.yaml +++ b/dts/bindings/rng/virtio,device4.yaml @@ -1,7 +1,7 @@ # Copyright (c) 2025 TOKITA Hiroshi # SPDX-License-Identifier: Apache-2.0 -description: VirtIO Entropy device (ID:4) +description: VIRTIO Entropy device (ID:4) compatible: "virtio,device4" From e75297235a7192fb86218c03c6145e19f7dc0890 Mon Sep 17 00:00:00 2001 From: TOKITA Hiroshi Date: Sat, 3 May 2025 11:13:30 +0900 Subject: [PATCH 2/5] drivers: virtio: add VIRTIO MMIO transport driver Add virtio-mmio driver Signed-off-by: TOKITA Hiroshi --- drivers/virtio/CMakeLists.txt | 1 + drivers/virtio/Kconfig | 7 + drivers/virtio/virtio_mmio.c | 350 +++++++++++++++++++++++++++ dts/bindings/virtio/virtio,mmio.yaml | 8 + 4 files changed, 366 insertions(+) create mode 100644 drivers/virtio/virtio_mmio.c create mode 100644 dts/bindings/virtio/virtio,mmio.yaml diff --git a/drivers/virtio/CMakeLists.txt b/drivers/virtio/CMakeLists.txt index 2d52d253cad4f..80e633236ebc3 100644 --- a/drivers/virtio/CMakeLists.txt +++ b/drivers/virtio/CMakeLists.txt @@ -5,3 +5,4 @@ zephyr_library() zephyr_library_sources_ifdef(CONFIG_VIRTIO virtqueue.c virtio_common.c) zephyr_library_sources_ifdef(CONFIG_VIRTIO_PCI virtio_pci.c) +zephyr_library_sources_ifdef(CONFIG_VIRTIO_MMIO virtio_mmio.c) diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig index 845844389c9c0..4c3d78a62e719 100644 --- a/drivers/virtio/Kconfig +++ b/drivers/virtio/Kconfig @@ -15,6 +15,13 @@ config VIRTIO_PCI help Enable options for VIRTIO over PCI +config VIRTIO_MMIO + bool "support for VIRTIO over MMIO" + default y + depends on DT_HAS_VIRTIO_MMIO_ENABLED + help + Enable options for VIRTIO over MMIO + endif # VIRTIO module = VIRTIO diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c new file mode 100644 index 0000000000000..814278333aaad --- /dev/null +++ b/drivers/virtio/virtio_mmio.c @@ -0,0 +1,350 @@ +/* + * Copyright (c) 2025 TOKITA Hiroshi + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "virtio_common.h" + +#define DT_DRV_COMPAT virtio_mmio + +LOG_MODULE_REGISTER(virtio_mmio, CONFIG_VIRTIO_LOG_LEVEL); + +/* + * Based on Virtual I/O Device (VIRTIO) Version 1.3 specification: + * https://docs.oasis-open.org/virtio/virtio/v1.3/csd01/virtio-v1.3-csd01.pdf + */ + +#define VIRTIO_MMIO_MAGIC_VALUE 0x000 +#define VIRTIO_MMIO_VERSION 0x004 +#define VIRTIO_MMIO_DEVICE_ID 0x008 +#define VIRTIO_MMIO_VENDOR_ID 0x00c +#define VIRTIO_MMIO_DEVICE_FEATURES 0x010 +#define VIRTIO_MMIO_DEVICE_FEATURES_SEL 0x014 +#define VIRTIO_MMIO_DRIVER_FEATURES 0x020 +#define VIRTIO_MMIO_DRIVER_FEATURES_SEL 0x024 +#define VIRTIO_MMIO_QUEUE_SEL 0x030 +#define VIRTIO_MMIO_QUEUE_SIZE_MAX 0x034 +#define VIRTIO_MMIO_QUEUE_SIZE 0x038 +#define VIRTIO_MMIO_QUEUE_READY 0x044 +#define VIRTIO_MMIO_QUEUE_NOTIFY 0x050 +#define VIRTIO_MMIO_INTERRUPT_STATUS 0x060 +#define VIRTIO_MMIO_INTERRUPT_ACK 0x064 +#define VIRTIO_MMIO_STATUS 0x070 +#define VIRTIO_MMIO_QUEUE_DESC_LOW 0x080 +#define VIRTIO_MMIO_QUEUE_DESC_HIGH 0x084 +#define VIRTIO_MMIO_QUEUE_DRIVER_LOW 0x090 +#define VIRTIO_MMIO_QUEUE_DRIVER_HIGH 0x094 +#define VIRTIO_MMIO_QUEUE_DEVICE_LOW 0x0a0 +#define VIRTIO_MMIO_QUEUE_DEVICE_HIGH 0x0a4 +#define VIRTIO_MMIO_QUEUE_SHM_SEL 0x0ac +#define VIRTIO_MMIO_QUEUE_SHM_LEN_LOW 0x0b0 +#define VIRTIO_MMIO_QUEUE_SHM_LEN_HIGH 0x0b4 +#define VIRTIO_MMIO_QUEUE_SHM_BASE_LOW 0x0b8 +#define VIRTIO_MMIO_QUEUE_SHM_BASE_HIGH 0x0bc +#define VIRTIO_MMIO_QUEUE_RESET 0x0c0 +#define VIRTIO_MMIO_QUEUE_CONFIG_GENERATION 0x0fc +#define VIRTIO_MMIO_CONFIG 0x100 + +#define VIRTIO_MMIO_MAGIC 0x74726976 +#define VIRTIO_MMIO_SUPPORTED_VERSION 2 +#define VIRTIO_MMIO_INVALID_DEVICE_ID 0 + +#define DEV_CFG(dev) ((const struct virtio_mmio_config *)(dev)->config) +#define DEV_DATA(dev) ((struct virtio_mmio_data *)(dev)->data) + +struct virtio_mmio_data { + DEVICE_MMIO_NAMED_RAM(reg_base); + + struct virtq *virtqueues; + uint16_t virtqueue_count; + + struct k_spinlock isr_lock; + struct k_spinlock notify_lock; +}; + +struct virtio_mmio_config { + DEVICE_MMIO_NAMED_ROM(reg_base); +}; + +static inline uint32_t virtio_mmio_read32(const struct device *dev, uint32_t offset) +{ + const mem_addr_t reg = DEVICE_MMIO_NAMED_GET(dev, reg_base) + offset; + uint32_t val; + + barrier_dmem_fence_full(); + val = sys_read32(reg); + return sys_le32_to_cpu(val); +} + +static inline void virtio_mmio_write32(const struct device *dev, uint32_t offset, uint32_t val) +{ + const mem_addr_t reg = DEVICE_MMIO_NAMED_GET(dev, reg_base) + offset; + + sys_write32(sys_cpu_to_le32(val), reg); + barrier_dmem_fence_full(); +} + +static void virtio_mmio_isr(const struct device *dev) +{ + struct virtio_mmio_data *data = dev->data; + k_spinlock_key_t key = k_spin_lock(&data->isr_lock); + const uint32_t isr_status = virtio_mmio_read32(dev, VIRTIO_MMIO_INTERRUPT_STATUS); + + virtio_mmio_write32(dev, VIRTIO_MMIO_INTERRUPT_ACK, isr_status); + virtio_isr(dev, isr_status, data->virtqueue_count); + + k_spin_unlock(&data->isr_lock, key); +} + +struct virtq *virtio_mmio_get_virtqueue(const struct device *dev, uint16_t queue_idx) +{ + struct virtio_mmio_data *data = dev->data; + + return queue_idx < data->virtqueue_count ? &data->virtqueues[queue_idx] : NULL; +} + +static void virtio_mmio_notify_queue(const struct device *dev, uint16_t queue_idx) +{ + struct virtio_mmio_data *data = dev->data; + + k_spinlock_key_t key = k_spin_lock(&data->notify_lock); + + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_NOTIFY, queue_idx); + + k_spin_unlock(&data->notify_lock, key); +} + +static void *virtio_mmio_get_device_specific_config(const struct device *dev) +{ + const mem_addr_t reg = DEVICE_MMIO_NAMED_GET(dev, reg_base) + VIRTIO_MMIO_CONFIG; + + barrier_dmem_fence_full(); + + return (void *)reg; +} + +static bool virtio_mmio_read_device_feature_bit(const struct device *dev, int bit) +{ + virtio_mmio_write32(dev, VIRTIO_MMIO_DEVICE_FEATURES_SEL, bit / 32); + const uint32_t val = virtio_mmio_read32(dev, VIRTIO_MMIO_DEVICE_FEATURES); + + return !!(val & BIT(bit % 32)); +} + +static void virtio_mmio_write_driver_feature_bit(const struct device *dev, int bit, bool value) +{ + const uint32_t mask = sys_cpu_to_le32(BIT(bit % 32)); + + virtio_mmio_write32(dev, VIRTIO_MMIO_DRIVER_FEATURES_SEL, bit / 32); + + const uint32_t regval = virtio_mmio_read32(dev, VIRTIO_MMIO_DRIVER_FEATURES); + + if (value) { + virtio_mmio_write32(dev, VIRTIO_MMIO_DRIVER_FEATURES, regval | mask); + } else { + virtio_mmio_write32(dev, VIRTIO_MMIO_DRIVER_FEATURES, regval & ~mask); + } +} + +static bool virtio_mmio_read_status_bit(const struct device *dev, int bit) +{ + const uint32_t val = virtio_mmio_read32(dev, VIRTIO_MMIO_STATUS); + + return !!(val & BIT(bit)); +} + +static void virtio_mmio_write_status_bit(const struct device *dev, int bit) +{ + const uint32_t mask = sys_cpu_to_le32(BIT(bit)); + const uint32_t val = virtio_mmio_read32(dev, VIRTIO_MMIO_STATUS); + + virtio_mmio_write32(dev, VIRTIO_MMIO_STATUS, val | mask); +} + +static int virtio_mmio_write_driver_feature_bit_range_check(const struct device *dev, int bit, + bool value) +{ + if (!IN_RANGE(bit, DEV_TYPE_FEAT_RANGE_0_BEGIN, DEV_TYPE_FEAT_RANGE_0_END) || + !IN_RANGE(bit, DEV_TYPE_FEAT_RANGE_1_BEGIN, DEV_TYPE_FEAT_RANGE_1_END)) { + return -EINVAL; + } + + virtio_mmio_write_driver_feature_bit(dev, bit, value); + + return 0; +} + +static int virtio_mmio_commit_feature_bits(const struct device *dev) +{ + virtio_mmio_write_status_bit(dev, DEVICE_STATUS_FEATURES_OK); + if (!virtio_mmio_read_status_bit(dev, DEVICE_STATUS_FEATURES_OK)) { + return -EINVAL; + } + + return 0; +} + +static void virtio_mmio_reset(const struct device *dev) +{ + virtio_mmio_write32(dev, VIRTIO_MMIO_STATUS, 0); + + while (virtio_mmio_read_status_bit(dev, VIRTIO_MMIO_STATUS) != 0) { + } +} + +static int virtio_mmio_set_virtqueue(const struct device *dev, uint16_t virtqueue_n, + struct virtq *virtqueue) +{ + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_SEL, virtqueue_n); + + uint16_t max_queue_size = virtio_mmio_read32(dev, VIRTIO_MMIO_QUEUE_SIZE_MAX); + + if (max_queue_size < virtqueue->num) { + LOG_ERR("%s doesn't support queue %d bigger than %d, tried to set " + "one with size %d", + dev->name, virtqueue_n, max_queue_size, virtqueue->num); + return -EINVAL; + } + + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_SIZE, virtqueue->num); + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_DESC_LOW, + k_mem_phys_addr(virtqueue->desc) & UINT32_MAX); + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_DESC_HIGH, + k_mem_phys_addr(virtqueue->desc) >> 32); + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_DRIVER_LOW, + k_mem_phys_addr(virtqueue->avail) & UINT32_MAX); + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_DRIVER_HIGH, + k_mem_phys_addr(virtqueue->avail) >> 32); + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_DEVICE_LOW, + k_mem_phys_addr(virtqueue->used) & UINT32_MAX); + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_DEVICE_HIGH, + k_mem_phys_addr(virtqueue->used) >> 32); + + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_READY, 1); + + return 0; +} + +static int virtio_mmio_set_virtqueues(const struct device *dev, uint16_t queue_count, + virtio_enumerate_queues cb, void *opaque) +{ + struct virtio_mmio_data *data = dev->data; + + data->virtqueues = k_malloc(queue_count * sizeof(struct virtq)); + if (!data->virtqueues) { + LOG_ERR("failed to allocate virtqueue array"); + return -ENOMEM; + } + data->virtqueue_count = queue_count; + + for (int i = 0; i < queue_count; i++) { + virtio_mmio_write32(dev, VIRTIO_MMIO_QUEUE_SEL, i); + + const uint16_t queue_size = + cb(i, virtio_mmio_read32(dev, VIRTIO_MMIO_QUEUE_SIZE_MAX), opaque); + + int ret = virtq_create(&data->virtqueues[i], queue_size); + + if (ret != 0) { + for (int j = 0; j < i; i++) { + virtq_free(&data->virtqueues[j]); + } + return ret; + } + ret = virtio_mmio_set_virtqueue(dev, i, &data->virtqueues[i]); + if (ret != 0) { + for (int j = 0; j < i; i++) { + virtq_free(&data->virtqueues[j]); + } + return ret; + } + } + + return 0; +} + +static int virtio_mmio_init_virtqueues(const struct device *dev, uint16_t num_queues, + virtio_enumerate_queues cb, void *opaque) +{ + return virtio_mmio_set_virtqueues(dev, num_queues, cb, opaque); +} + +static void virtio_mmio_finalize_init(const struct device *dev) +{ + virtio_mmio_write_status_bit(dev, DEVICE_STATUS_DRIVER_OK); +} + +static const struct virtio_driver_api virtio_mmio_driver_api = { + .get_virtqueue = virtio_mmio_get_virtqueue, + .notify_virtqueue = virtio_mmio_notify_queue, + .get_device_specific_config = virtio_mmio_get_device_specific_config, + .read_device_feature_bit = virtio_mmio_read_device_feature_bit, + .write_driver_feature_bit = virtio_mmio_write_driver_feature_bit_range_check, + .commit_feature_bits = virtio_mmio_commit_feature_bits, + .init_virtqueues = virtio_mmio_init_virtqueues, + .finalize_init = virtio_mmio_finalize_init, +}; + +static int virtio_mmio_init_common(const struct device *dev) +{ + DEVICE_MMIO_NAMED_MAP(dev, reg_base, K_MEM_CACHE_NONE); + + const uint32_t magic = virtio_mmio_read32(dev, VIRTIO_MMIO_MAGIC_VALUE); + + if (magic != VIRTIO_MMIO_MAGIC) { + LOG_ERR("Invalid magic value %x", magic); + return -EINVAL; + } + + const uint32_t version = virtio_mmio_read32(dev, VIRTIO_MMIO_VERSION); + + if (version != VIRTIO_MMIO_SUPPORTED_VERSION) { + LOG_ERR("Invalid version %x", version); + return -EINVAL; + } + + const uint32_t dev_id = virtio_mmio_read32(dev, VIRTIO_MMIO_DEVICE_ID); + + if (dev_id == VIRTIO_MMIO_INVALID_DEVICE_ID) { + LOG_ERR("Invalid device id %x", dev_id); + return -EINVAL; + } + + LOG_DBG("VENDOR_ID = %x", virtio_mmio_read32(dev, VIRTIO_MMIO_VENDOR_ID)); + + virtio_mmio_reset(dev); + + virtio_mmio_write_status_bit(dev, DEVICE_STATUS_ACKNOWLEDGE); + virtio_mmio_write_status_bit(dev, DEVICE_STATUS_DRIVER); + + virtio_mmio_write_driver_feature_bit(dev, VIRTIO_F_VERSION_1, true); + + return 0; +}; + +#define VIRTIO_MMIO_DEFINE(inst) \ + static struct virtio_mmio_data virtio_mmio_data##inst; \ + static struct virtio_mmio_config virtio_mmio_config##inst = { \ + DEVICE_MMIO_NAMED_ROM_INIT(reg_base, DT_DRV_INST(inst)), \ + }; \ + static int virtio_mmio_init##inst(const struct device *dev) \ + { \ + IRQ_CONNECT(DT_INST_IRQN(inst), DT_INST_IRQ(inst, priority), virtio_mmio_isr, \ + DEVICE_DT_INST_GET(inst), 0); \ + int ret = virtio_mmio_init_common(dev); \ + irq_enable(DT_INST_IRQN(inst)); \ + return ret; \ + } \ + DEVICE_DT_INST_DEFINE(inst, virtio_mmio_init##inst, NULL, &virtio_mmio_data##inst, \ + &virtio_mmio_config##inst, POST_KERNEL, 0, &virtio_mmio_driver_api); + +DT_INST_FOREACH_STATUS_OKAY(VIRTIO_MMIO_DEFINE) diff --git a/dts/bindings/virtio/virtio,mmio.yaml b/dts/bindings/virtio/virtio,mmio.yaml new file mode 100644 index 0000000000000..8445187026060 --- /dev/null +++ b/dts/bindings/virtio/virtio,mmio.yaml @@ -0,0 +1,8 @@ +# Copyright (c) 2025 TOKITA Hiroshi +# SPDX-License-Identifier: Apache-2.0 + +description: VIRTIO over MMIO + +compatible: "virtio,mmio" + +include: [base.yaml] From 3b051760067e6c369df7ef8dcecd6ea137e0fe32 Mon Sep 17 00:00:00 2001 From: TOKITA Hiroshi Date: Sun, 4 May 2025 17:15:32 +0900 Subject: [PATCH 3/5] boards: qemu: cortex_a53: add virtio-mmio configuration Add `virtio-mmio` nodes that are retrieved from qemu internal devicetree dump, to dts. Also, enable the virtio-rng device on the command line. Note: Ideally, it would be possible to dynamically generate the command line by looking at the devicetree state, but this PR is a fixed implementation to simplify it. This will be addressed separately. Signed-off-by: TOKITA Hiroshi --- boards/qemu/cortex_a53/board.cmake | 6 + boards/qemu/cortex_a53/qemu_cortex_a53.dts | 223 +++++++++++++++++++++ 2 files changed, 229 insertions(+) diff --git a/boards/qemu/cortex_a53/board.cmake b/boards/qemu/cortex_a53/board.cmake index 7cc424e4544c5..90c1739dfea0c 100644 --- a/boards/qemu/cortex_a53/board.cmake +++ b/boards/qemu/cortex_a53/board.cmake @@ -12,8 +12,14 @@ else() set(QEMU_MACH virt,secure=on,gic-version=3) endif() +if(CONFIG_ENTROPY_VIRTIO) + set(QEMU_VIRTIO_ENTROPY_FLAGS -device virtio-rng-device,bus=virtio-mmio-bus.0) +endif() + set(QEMU_FLAGS_${ARCH} + -global virtio-mmio.force-legacy=false -cpu ${QEMU_CPU_TYPE_${ARCH}} + ${QEMU_VIRTIO_ENTROPY_FLAGS} -nographic -machine ${QEMU_MACH} ) diff --git a/boards/qemu/cortex_a53/qemu_cortex_a53.dts b/boards/qemu/cortex_a53/qemu_cortex_a53.dts index ef1324d019989..41cba16b437c0 100644 --- a/boards/qemu/cortex_a53/qemu_cortex_a53.dts +++ b/boards/qemu/cortex_a53/qemu_cortex_a53.dts @@ -31,6 +31,229 @@ reg = <0x0 0x40000000 0x0 DT_SIZE_M(128)>; }; + virtio_mmio0: virtio_mmio@a000000 { + compatible = "virtio,mmio"; + reg = <0x0 0xa000000 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio1: virtio_mmio@a000200 { + compatible = "virtio,mmio"; + reg = <0x0 0xa000200 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio2: virtio_mmio@a000400 { + compatible = "virtio,mmio"; + reg = <0x0 0xa000400 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio3: virtio_mmio@a000600 { + compatible = "virtio,mmio"; + reg = <0x0 0xa000600 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio4: virtio_mmio@a000800 { + compatible = "virtio,mmio"; + reg = <0x0 0xa000800 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio5: virtio_mmio@a000a00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa000a00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio6: virtio_mmio@a000c00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa000c00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio7: virtio_mmio@a000e00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa000e00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio8: virtio_mmio@a001000 { + compatible = "virtio,mmio"; + interrupts = ; + reg = <0x0 0xa001000 0x0 0x200>; + status = "disabled"; + }; + + virtio_mmio9: virtio_mmio@a001200 { + compatible = "virtio,mmio"; + reg = <0x0 0xa001200 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio10: virtio_mmio@a001400 { + compatible = "virtio,mmio"; + reg = <0x0 0xa001400 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio11: virtio_mmio@a001600 { + compatible = "virtio,mmio"; + reg = <0x0 0xa001600 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio12: virtio_mmio@a001800 { + compatible = "virtio,mmio"; + reg = <0x0 0xa001800 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio13: virtio_mmio@a001a00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa001a00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio14: virtio_mmio@a001c00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa001c00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio15: virtio_mmio@a001e00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa001e00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio16: virtio_mmio@a002000 { + compatible = "virtio,mmio"; + reg = <0x0 0xa002000 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio17: virtio_mmio@a002200 { + compatible = "virtio,mmio"; + reg = <0x0 0xa002200 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio18: virtio_mmio@a002400 { + compatible = "virtio,mmio"; + reg = <0x0 0xa002400 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio19: virtio_mmio@a002600 { + compatible = "virtio,mmio"; + reg = <0x0 0xa002600 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio20: virtio_mmio@a002800 { + compatible = "virtio,mmio"; + reg = <0x0 0xa002800 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio21: virtio_mmio@a002a00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa002a00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio22: virtio_mmio@a002c00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa002c00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio23: virtio_mmio@a002e00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa002e00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio24: virtio_mmio@a003000 { + compatible = "virtio,mmio"; + reg = <0x0 0xa003000 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio25: virtio_mmio@a003200 { + compatible = "virtio,mmio"; + reg = <0x0 0xa003200 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio26: virtio_mmio@a003400 { + compatible = "virtio,mmio"; + reg = <0x0 0xa003400 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio27: virtio_mmio@a003600 { + compatible = "virtio,mmio"; + reg = <0x0 0xa003600 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio28: virtio_mmio@a003800 { + compatible = "virtio,mmio"; + reg = <0x0 0xa003800 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio29: virtio_mmio@a003a00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa003a00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio30: virtio_mmio@a003c00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa003c00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; + + virtio_mmio31: virtio_mmio@a003e00 { + compatible = "virtio,mmio"; + reg = <0x0 0xa003e00 0x0 0x200>; + interrupts = ; + status = "disabled"; + }; }; }; From 0c6ad17f235a96d25640fa56b82b476358811a9c Mon Sep 17 00:00:00 2001 From: TOKITA Hiroshi Date: Mon, 5 May 2025 12:19:15 +0900 Subject: [PATCH 4/5] tests: drivers: build_all: virtio: add VIRTIO MMIO build test Add the `qemu_cortex_a53` configuration to run the build test for the VIRTIO MMIO driver. To add this test, we have split the virtio-pci and virtio-mmio test cases. Signed-off-by: TOKITA Hiroshi --- .../virtio/boards/qemu_cortex_a53.overlay | 20 +++++++++++++++++++ tests/drivers/build_all/virtio/prj.conf | 1 - tests/drivers/build_all/virtio/testcase.yaml | 8 ++++++-- 3 files changed, 26 insertions(+), 3 deletions(-) create mode 100644 tests/drivers/build_all/virtio/boards/qemu_cortex_a53.overlay diff --git a/tests/drivers/build_all/virtio/boards/qemu_cortex_a53.overlay b/tests/drivers/build_all/virtio/boards/qemu_cortex_a53.overlay new file mode 100644 index 0000000000000..678532a9cb7ba --- /dev/null +++ b/tests/drivers/build_all/virtio/boards/qemu_cortex_a53.overlay @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2025 TOKITA Hiroshi + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/ { + chosen { + zephyr,entropy = &virtio_entropy; + }; +}; + +&virtio_mmio0 { + status = "okay"; + + virtio_entropy: virtio_entropy { + compatible = "virtio,device4"; + status = "okay"; + }; +}; diff --git a/tests/drivers/build_all/virtio/prj.conf b/tests/drivers/build_all/virtio/prj.conf index 5d565a1168572..da30e358fc482 100644 --- a/tests/drivers/build_all/virtio/prj.conf +++ b/tests/drivers/build_all/virtio/prj.conf @@ -1,5 +1,4 @@ CONFIG_TEST=y CONFIG_VIRTIO=y -CONFIG_PCIE=y CONFIG_HEAP_MEM_POOL_SIZE=1024 CONFIG_ENTROPY_GENERATOR=y diff --git a/tests/drivers/build_all/virtio/testcase.yaml b/tests/drivers/build_all/virtio/testcase.yaml index 1e715abb80a0f..37bade0655605 100644 --- a/tests/drivers/build_all/virtio/testcase.yaml +++ b/tests/drivers/build_all/virtio/testcase.yaml @@ -1,8 +1,12 @@ common: - filter: CONFIG_DT_HAS_VIRTIO_PCI_ENABLED build_only: true tags: - drivers - virtio tests: - drivers.virtio_pci.build: {} + drivers.virtio_pci.build: + extra_configs: + - CONFIG_PCIE=y + filter: CONFIG_DT_HAS_VIRTIO_PCI_ENABLED + drivers.virtio_mmio.build: + filter: CONFIG_DT_HAS_VIRTIO_MMIO_ENABLED From ae38ed6042b299eff21e85b74fbf74899c2ac360 Mon Sep 17 00:00:00 2001 From: TOKITA Hiroshi Date: Sun, 4 May 2025 17:58:36 +0900 Subject: [PATCH 5/5] tests: drivers: entropy: api: add qemu_cortex_a53 configuration Add `qemu_cortex_a53` target which has the `virtio,entropy` device. Signed-off-by: TOKITA Hiroshi --- .../entropy/api/boards/qemu_cortex_a53.conf | 1 + .../api/boards/qemu_cortex_a53.overlay | 20 +++++++++++++++++++ 2 files changed, 21 insertions(+) create mode 100644 tests/drivers/entropy/api/boards/qemu_cortex_a53.conf create mode 100644 tests/drivers/entropy/api/boards/qemu_cortex_a53.overlay diff --git a/tests/drivers/entropy/api/boards/qemu_cortex_a53.conf b/tests/drivers/entropy/api/boards/qemu_cortex_a53.conf new file mode 100644 index 0000000000000..6d6d574fffa80 --- /dev/null +++ b/tests/drivers/entropy/api/boards/qemu_cortex_a53.conf @@ -0,0 +1 @@ +CONFIG_HEAP_MEM_POOL_SIZE=1024 diff --git a/tests/drivers/entropy/api/boards/qemu_cortex_a53.overlay b/tests/drivers/entropy/api/boards/qemu_cortex_a53.overlay new file mode 100644 index 0000000000000..678532a9cb7ba --- /dev/null +++ b/tests/drivers/entropy/api/boards/qemu_cortex_a53.overlay @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2025 TOKITA Hiroshi + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/ { + chosen { + zephyr,entropy = &virtio_entropy; + }; +}; + +&virtio_mmio0 { + status = "okay"; + + virtio_entropy: virtio_entropy { + compatible = "virtio,device4"; + status = "okay"; + }; +};