* [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support
@ 2018-09-23 13:41 Bin Meng
2018-09-23 13:41 ` [U-Boot] [PATCH 01/27] dm: core: Allow uclass to set up a device's child after it is probed Bin Meng
` (27 more replies)
0 siblings, 28 replies; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:41 UTC (permalink / raw)
To: u-boot
This series brings in VirtIO driver support in U-Boot. The work is based
on Tuomas's virtio support on QEMU ARM targets.
VirtIO is a virtualization standard for network and disk device drivers
where just the guest's device driver "knows" it is running in a virtual
environment, and cooperates with the hypervisor. This enables guests to
get high performance network and disk operations, and gives most of the
performance benefits of paravirtualization. In the U-Boot case, the
guest is U-Boot itself, while the virtual environment are normally QEMU
targets like ARM, RISC-V and x86.
Both VirtIO MMIO and PCI transport options are supported. Only VirtIO
network and block device drivers are supported for now.
The following QEMU targets are supported.
- qemu_arm_defconfig
- qemu_arm64_defconfig
- qemu-riscv32_defconfig
- qemu-riscv64_defconfig
- qemu-x86_defconfig
- qemu-x86_64_defconfig
A new child_post_probe() uclass driver method is introduced to better
support virtio device driver. This also changes BLK uclass driver to
supply a post_probe() method which calls part_init(), so that we can
avoid duplicating such call in every BLK driver.
Not every checkpatch warning reported was fixed, but I tried to fix as
many as possible which makes sense.
This series needs to be applied after the risc-v QEMU series is applied.
This series is available at u-boot-x86/virtio-working for testing.
Note the branch already contains the risc-v QEMU series plus one network
stack fix to make virtio-net driver happy.
Bin Meng (22):
dm: core: Allow uclass to set up a device's child after it is probed
dm: Add a new uclass driver for VirtIO transport devices
virtio: Add virtio over mmio transport driver
test: dm: blk: Correct blk_base test case
sandbox: blk: Switch to use platdata_auto_alloc_size for the driver
data
efi_driver: blk: Switch to use platdata_auto_alloc_size for the driver
data
blk: Call part_init() in the post_probe() method
blk: Drop blk_prepare_device()
blk: Make blk_next_free_devnum() public
arm: qemu: Add a Kconfig in the board directory
arm: qemu: Enumerate virtio bus during early boot
riscv: qemu: Enumerate virtio bus during early boot
riscv: qemu: Include some useful commands
kconfig: Introduce HAVE_ARCH_IOMAP
x86: Implement arch-specific io accessor routines
virtio: Add virtio over pci transport driver
x86: qemu: Imply virtio PCI transport and device drivers
dm: pci: Add APIs to find next capability and extended capability
test: dm: pci: Add cases for finding next PCI capability APIs
virtio: pci: Support non-legacy PCI transport device
virtio: net: Support non-legacy device
doc: Document virtio support
Tuomas Tynkkynen (5):
virtio: Add codes for virtual queue/ring management
virtio: Add net driver support
blk: Introduce IF_TYPE_VIRTIO
virtio: Add block driver support
virtio: cmd: Add virtio command for virtio block devices
arch/Kconfig | 1 +
arch/arm/Kconfig | 1 +
arch/x86/include/asm/io.h | 66 +++
board/emulation/qemu-arm/Kconfig | 12 +
board/emulation/qemu-arm/qemu-arm.c | 7 +
board/emulation/qemu-riscv/Kconfig | 11 +
board/emulation/qemu-riscv/qemu-riscv.c | 7 +
board/emulation/qemu-x86/Kconfig | 3 +
cmd/Kconfig | 7 +
cmd/Makefile | 1 +
cmd/sata.c | 9 -
cmd/virtio.c | 37 ++
common/usb_storage.c | 4 +-
configs/qemu_arm64_defconfig | 1 -
configs/qemu_arm_defconfig | 1 -
disk/part.c | 6 +
doc/README.virtio | 247 ++++++++++++
drivers/Kconfig | 2 +
drivers/Makefile | 1 +
drivers/block/blk-uclass.c | 25 +-
drivers/block/ide.c | 2 -
drivers/block/sandbox.c | 17 +-
drivers/core/uclass.c | 13 +-
drivers/mmc/mmc.c | 3 -
drivers/nvme/nvme.c | 1 -
drivers/pci/pci-uclass.c | 48 ++-
drivers/scsi/scsi.c | 1 -
drivers/virtio/Kconfig | 43 ++
drivers/virtio/Makefile | 10 +
drivers/virtio/virtio-uclass.c | 333 +++++++++++++++
drivers/virtio/virtio_blk.c | 127 ++++++
drivers/virtio/virtio_blk.h | 129 ++++++
drivers/virtio/virtio_mmio.c | 413 +++++++++++++++++++
drivers/virtio/virtio_mmio.h | 129 ++++++
drivers/virtio/virtio_net.c | 236 +++++++++++
drivers/virtio/virtio_net.h | 268 ++++++++++++
drivers/virtio/virtio_pci.h | 173 ++++++++
drivers/virtio/virtio_pci_legacy.c | 420 +++++++++++++++++++
drivers/virtio/virtio_pci_modern.c | 612 ++++++++++++++++++++++++++++
drivers/virtio/virtio_ring.c | 356 ++++++++++++++++
include/blk.h | 22 +-
include/dm/uclass-id.h | 1 +
include/dm/uclass.h | 4 +-
include/linux/io.h | 4 +
include/pci.h | 48 +++
include/virtio.h | 694 ++++++++++++++++++++++++++++++++
include/virtio_ring.h | 320 +++++++++++++++
include/virtio_types.h | 24 ++
lib/Kconfig | 6 +
lib/efi_driver/efi_block_device.c | 26 +-
test/dm/blk.c | 27 +-
test/dm/pci.c | 20 +
52 files changed, 4882 insertions(+), 97 deletions(-)
create mode 100644 board/emulation/qemu-arm/Kconfig
create mode 100644 cmd/virtio.c
create mode 100644 doc/README.virtio
create mode 100644 drivers/virtio/Kconfig
create mode 100644 drivers/virtio/Makefile
create mode 100644 drivers/virtio/virtio-uclass.c
create mode 100644 drivers/virtio/virtio_blk.c
create mode 100644 drivers/virtio/virtio_blk.h
create mode 100644 drivers/virtio/virtio_mmio.c
create mode 100644 drivers/virtio/virtio_mmio.h
create mode 100644 drivers/virtio/virtio_net.c
create mode 100644 drivers/virtio/virtio_net.h
create mode 100644 drivers/virtio/virtio_pci.h
create mode 100644 drivers/virtio/virtio_pci_legacy.c
create mode 100644 drivers/virtio/virtio_pci_modern.c
create mode 100644 drivers/virtio/virtio_ring.c
create mode 100644 include/virtio.h
create mode 100644 include/virtio_ring.h
create mode 100644 include/virtio_types.h
--
2.7.4
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 01/27] dm: core: Allow uclass to set up a device's child after it is probed
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
@ 2018-09-23 13:41 ` Bin Meng
2018-09-27 13:41 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices Bin Meng
` (26 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:41 UTC (permalink / raw)
To: u-boot
Some buses need to set up their child devices after they are probed.
Support a common child_post_probe() method for the uclass.
With this change, the two APIs uclass_pre_probe_device() and
uclass_post_probe_device() become symmetric.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/core/uclass.c | 13 ++++++++++++-
include/dm/uclass.h | 4 +++-
2 files changed, 15 insertions(+), 2 deletions(-)
diff --git a/drivers/core/uclass.c b/drivers/core/uclass.c
index 3113d6a..3c7b9cf 100644
--- a/drivers/core/uclass.c
+++ b/drivers/core/uclass.c
@@ -687,8 +687,19 @@ int uclass_pre_probe_device(struct udevice *dev)
int uclass_post_probe_device(struct udevice *dev)
{
- struct uclass_driver *uc_drv = dev->uclass->uc_drv;
+ struct uclass_driver *uc_drv;
+ int ret;
+
+ if (dev->parent) {
+ uc_drv = dev->parent->uclass->uc_drv;
+ if (uc_drv->child_post_probe) {
+ ret = uc_drv->child_post_probe(dev);
+ if (ret)
+ return ret;
+ }
+ }
+ uc_drv = dev->uclass->uc_drv;
if (uc_drv->post_probe)
return uc_drv->post_probe(dev);
diff --git a/include/dm/uclass.h b/include/dm/uclass.h
index 6e7c1cd..610c68d 100644
--- a/include/dm/uclass.h
+++ b/include/dm/uclass.h
@@ -58,7 +58,8 @@ struct udevice;
* @post_probe: Called after a new device is probed
* @pre_remove: Called before a device is removed
* @child_post_bind: Called after a child is bound to a device in this uclass
- * @child_pre_probe: Called before a child is probed in this uclass
+ * @child_pre_probe: Called before a child in this uclass is probed
+ * @child_post_probe: Called after a child in this uclass is probed
* @init: Called to set up the uclass
* @destroy: Called to destroy the uclass
* @priv_auto_alloc_size: If non-zero this is the size of the private data
@@ -91,6 +92,7 @@ struct uclass_driver {
int (*pre_remove)(struct udevice *dev);
int (*child_post_bind)(struct udevice *dev);
int (*child_pre_probe)(struct udevice *dev);
+ int (*child_post_probe)(struct udevice *dev);
int (*init)(struct uclass *class);
int (*destroy)(struct uclass *class);
int priv_auto_alloc_size;
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
2018-09-23 13:41 ` [U-Boot] [PATCH 01/27] dm: core: Allow uclass to set up a device's child after it is probed Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-27 22:10 ` Tuomas Tynkkynen
2018-09-23 13:42 ` [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management Bin Meng
` (25 subsequent siblings)
27 siblings, 2 replies; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
This adds a new virtio uclass driver for “virtio” [1] family of
devices that are are found in virtual environments like QEMU,
yet by design they look like physical devices to the guest.
The uclass driver provides child_pre_probe() and child_post_probe()
methods to do some common operations for virtio device drivers like
device and driver supported feature negotiation, etc.
[1] http://docs.oasis-open.org/virtio/virtio/v1.0/virtio-v1.0.pdf
Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/Kconfig | 2 +
drivers/Makefile | 1 +
drivers/virtio/Kconfig | 14 +
drivers/virtio/Makefile | 6 +
drivers/virtio/virtio-uclass.c | 333 ++++++++++++++++++++
include/dm/uclass-id.h | 1 +
include/virtio.h | 694 +++++++++++++++++++++++++++++++++++++++++
include/virtio_types.h | 24 ++
8 files changed, 1075 insertions(+)
create mode 100644 drivers/virtio/Kconfig
create mode 100644 drivers/virtio/Makefile
create mode 100644 drivers/virtio/virtio-uclass.c
create mode 100644 include/virtio.h
create mode 100644 include/virtio_types.h
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 56536c4..d40db0d 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -106,6 +106,8 @@ source "drivers/usb/Kconfig"
source "drivers/video/Kconfig"
+source "drivers/virtio/Kconfig"
+
source "drivers/watchdog/Kconfig"
config PHYS_TO_BUS
diff --git a/drivers/Makefile b/drivers/Makefile
index 23ea609..f09daae 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_$(SPL_TPL_)SERIAL_SUPPORT) += serial/
obj-$(CONFIG_$(SPL_TPL_)SPI_FLASH_SUPPORT) += mtd/spi/
obj-$(CONFIG_$(SPL_TPL_)SPI_SUPPORT) += spi/
obj-$(CONFIG_$(SPL_TPL_)TIMER) += timer/
+obj-$(CONFIG_$(SPL_TPL_)VIRTIO) += virtio/
obj-$(CONFIG_$(SPL_)DM_MAILBOX) += mailbox/
obj-$(CONFIG_$(SPL_)REMOTEPROC) += remoteproc/
diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
new file mode 100644
index 0000000..bdfa96a
--- /dev/null
+++ b/drivers/virtio/Kconfig
@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: GPL-2.0+
+#
+# Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+# Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+
+menu "VirtIO Drivers"
+
+config VIRTIO
+ bool
+ help
+ This option is selected by any driver which implements the virtio
+ bus, such as CONFIG_VIRTIO_MMIO or CONFIG_VIRTIO_PCI.
+
+endmenu
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
new file mode 100644
index 0000000..23e7be7
--- /dev/null
+++ b/drivers/virtio/Makefile
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: GPL-2.0+
+#
+# Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+# Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+
+obj-y += virtio-uclass.o
diff --git a/drivers/virtio/virtio-uclass.c b/drivers/virtio/virtio-uclass.c
new file mode 100644
index 0000000..1c85856
--- /dev/null
+++ b/drivers/virtio/virtio-uclass.c
@@ -0,0 +1,333 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <virtio.h>
+#include <dm/device.h>
+#include <dm/lists.h>
+
+static const char *const virtio_drv_name[VIRTIO_ID_MAX_NUM] = {
+ [VIRTIO_ID_NET] = VIRTIO_NET_DRV_NAME,
+ [VIRTIO_ID_BLOCK] = VIRTIO_BLK_DRV_NAME,
+};
+
+int virtio_get_config(struct udevice *vdev, unsigned int offset,
+ void *buf, unsigned int len)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->get_config)
+ return -ENOSYS;
+ return ops->get_config(vdev->parent, offset, buf, len);
+}
+
+int virtio_set_config(struct udevice *vdev, unsigned int offset,
+ void *buf, unsigned int len)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->set_config)
+ return -ENOSYS;
+ return ops->set_config(vdev->parent, offset, buf, len);
+}
+
+int virtio_generation(struct udevice *vdev, u32 *counter)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->generation)
+ return -ENOSYS;
+ return ops->generation(vdev->parent, counter);
+}
+
+int virtio_get_status(struct udevice *vdev, u8 *status)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->get_status)
+ return -ENOSYS;
+ return ops->get_status(vdev->parent, status);
+}
+
+int virtio_set_status(struct udevice *vdev, u8 status)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->set_status)
+ return -ENOSYS;
+ return ops->set_status(vdev->parent, status);
+}
+
+int virtio_reset(struct udevice *vdev)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->reset)
+ return -ENOSYS;
+ return ops->reset(vdev->parent);
+}
+
+int virtio_get_features(struct udevice *vdev, u64 *features)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->get_features)
+ return -ENOSYS;
+ return ops->get_features(vdev->parent, features);
+}
+
+int virtio_set_features(struct udevice *vdev)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->set_features)
+ return -ENOSYS;
+ return ops->set_features(vdev->parent);
+}
+
+int virtio_find_vqs(struct udevice *vdev, unsigned int nvqs,
+ struct virtqueue *vqs[])
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->find_vqs)
+ return -ENOSYS;
+ return ops->find_vqs(vdev->parent, nvqs, vqs);
+}
+
+int virtio_del_vqs(struct udevice *vdev)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->del_vqs)
+ return -ENOSYS;
+ return ops->del_vqs(vdev->parent);
+}
+
+int virtio_notify(struct udevice *vdev, struct virtqueue *vq)
+{
+ struct dm_virtio_ops *ops;
+
+ ops = virtio_get_ops(vdev->parent);
+ if (!ops->notify)
+ return -ENOSYS;
+ return ops->notify(vdev->parent, vq);
+}
+
+void virtio_add_status(struct udevice *vdev, u8 status)
+{
+ u8 old;
+
+ if (!virtio_get_status(vdev, &old))
+ virtio_set_status(vdev, old | status);
+}
+
+int virtio_finalize_features(struct udevice *vdev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
+ u8 status;
+ int ret;
+
+ ret = virtio_set_features(vdev);
+ if (ret)
+ return ret;
+
+ if (uc_priv->legacy)
+ return 0;
+
+ virtio_add_status(vdev, VIRTIO_CONFIG_S_FEATURES_OK);
+ ret = virtio_get_status(vdev, &status);
+ if (ret)
+ return ret;
+ if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
+ debug("(%s): device refuses features %x\n", vdev->name, status);
+ return -ENODEV;
+ }
+
+ return 0;
+}
+
+void virtio_driver_features_init(struct virtio_dev_priv *priv,
+ u32 *feature, u32 feature_size,
+ u32 *feature_legacy, u32 feature_legacy_size)
+{
+ priv->feature_table = feature;
+ priv->feature_table_size = feature_size;
+ priv->feature_table_legacy = feature_legacy;
+ priv->feature_table_size_legacy = feature_legacy_size;
+}
+
+void virtio_init(void)
+{
+ struct udevice *bus;
+
+ /* Enumerate all known virtio devices */
+ for (uclass_first_device(UCLASS_VIRTIO, &bus);
+ bus;
+ uclass_next_device(&bus)) {
+ ;
+ }
+}
+
+static int virtio_uclass_post_probe(struct udevice *udev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+ char dev_name[30], *str;
+ struct udevice *vdev;
+ int ret;
+
+ if (uc_priv->device > VIRTIO_ID_MAX_NUM) {
+ debug("(%s): virtio device ID %d exceeds maximum num\n",
+ udev->name, uc_priv->device);
+ return 0;
+ }
+
+ if (!virtio_drv_name[uc_priv->device]) {
+ debug("(%s): underlying virtio device driver unavailable\n",
+ udev->name);
+ return 0;
+ }
+
+ snprintf(dev_name, sizeof(dev_name), "%s#%d",
+ virtio_drv_name[uc_priv->device], udev->seq);
+ str = strdup(dev_name);
+ if (!str)
+ return -ENOMEM;
+
+ ret = device_bind_driver(udev, virtio_drv_name[uc_priv->device],
+ str, &vdev);
+ if (ret == -ENOENT) {
+ debug("(%s): no driver configured\n", udev->name);
+ return 0;
+ }
+ if (ret) {
+ free(str);
+ return ret;
+ }
+ device_set_name_alloced(vdev);
+
+ return 0;
+}
+
+static int virtio_uclass_child_post_bind(struct udevice *vdev)
+{
+ /* Acknowledge that we've seen the device */
+ virtio_add_status(vdev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
+
+ return 0;
+}
+
+static int virtio_uclass_child_pre_probe(struct udevice *vdev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
+ u64 device_features;
+ u64 driver_features;
+ u64 driver_features_legacy;
+ int i;
+ int ret;
+
+ /*
+ * Save the real virtio device (eg: virtio-net, virtio-blk) to
+ * the transport (parent) device's uclass priv for future use.
+ */
+ uc_priv->vdev = vdev;
+
+ /*
+ * We always start by resetting the device, in case a previous driver
+ * messed it up. This also tests that code path a little.
+ */
+ ret = virtio_reset(vdev);
+ if (ret)
+ goto err;
+
+ /* We have a driver! */
+ virtio_add_status(vdev, VIRTIO_CONFIG_S_DRIVER);
+
+ /* Figure out what features the device supports */
+ virtio_get_features(vdev, &device_features);
+ debug("(%s) plain device features supported %016llx\n",
+ vdev->name, device_features);
+ if (!(device_features & (1ULL << VIRTIO_F_VERSION_1)))
+ uc_priv->legacy = true;
+
+ /* Figure out what features the driver supports */
+ driver_features = 0;
+ for (i = 0; i < uc_priv->feature_table_size; i++) {
+ unsigned int f = uc_priv->feature_table[i];
+
+ WARN_ON(f >= 64);
+ driver_features |= (1ULL << f);
+ }
+
+ /* Some drivers have a separate feature table for virtio v1.0 */
+ if (uc_priv->feature_table_legacy) {
+ driver_features_legacy = 0;
+ for (i = 0; i < uc_priv->feature_table_size_legacy; i++) {
+ unsigned int f = uc_priv->feature_table_legacy[i];
+
+ WARN_ON(f >= 64);
+ driver_features_legacy |= (1ULL << f);
+ }
+ } else {
+ driver_features_legacy = driver_features;
+ }
+
+ if (uc_priv->legacy) {
+ debug("(%s): legacy virtio device\n", vdev->name);
+ uc_priv->features = driver_features_legacy & device_features;
+ } else {
+ debug("(%s): v1.0 complaint virtio device\n", vdev->name);
+ uc_priv->features = driver_features & device_features;
+ }
+
+ /* Transport features always preserved to pass to finalize_features */
+ for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)
+ if ((device_features & (1ULL << i)) &&
+ (i == VIRTIO_F_VERSION_1))
+ __virtio_set_bit(vdev->parent, i);
+
+ debug("(%s) final negotiated features supported %016llx\n",
+ vdev->name, uc_priv->features);
+ ret = virtio_finalize_features(vdev);
+ if (ret)
+ goto err;
+
+ return 0;
+
+err:
+ virtio_add_status(vdev, VIRTIO_CONFIG_S_FAILED);
+ return ret;
+}
+
+static int virtio_uclass_child_post_probe(struct udevice *vdev)
+{
+ /* Indicates that the driver is set up and ready to drive the device */
+ virtio_add_status(vdev, VIRTIO_CONFIG_S_DRIVER_OK);
+
+ return 0;
+}
+
+UCLASS_DRIVER(virtio) = {
+ .name = "virtio",
+ .id = UCLASS_VIRTIO,
+ .flags = DM_UC_FLAG_SEQ_ALIAS,
+ .post_probe = virtio_uclass_post_probe,
+ .child_post_bind = virtio_uclass_child_post_bind,
+ .child_pre_probe = virtio_uclass_child_pre_probe,
+ .child_post_probe = virtio_uclass_child_post_probe,
+ .per_device_auto_alloc_size = sizeof(struct virtio_dev_priv),
+};
diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h
index 7027ea0..08b2a8f 100644
--- a/include/dm/uclass-id.h
+++ b/include/dm/uclass-id.h
@@ -93,6 +93,7 @@ enum uclass_id {
UCLASS_VIDEO_BRIDGE, /* Video bridge, e.g. DisplayPort to LVDS */
UCLASS_VIDEO_CONSOLE, /* Text console driver for video device */
UCLASS_WDT, /* Watchdot Timer driver */
+ UCLASS_VIRTIO, /* VirtIO transport device */
UCLASS_COUNT,
UCLASS_INVALID = -1,
diff --git a/include/virtio.h b/include/virtio.h
new file mode 100644
index 0000000..efbedb2
--- /dev/null
+++ b/include/virtio.h
@@ -0,0 +1,694 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * This file is largely based on Linux kernel virtio_*.h files
+ */
+
+#ifndef __VIRTIO_H__
+#define __VIRTIO_H__
+
+#include <virtio_types.h>
+#include <dm/device.h>
+
+#define VIRTIO_ID_NET 1 /* virtio net */
+#define VIRTIO_ID_BLOCK 2 /* virtio block */
+#define VIRTIO_ID_MAX_NUM 3
+
+#define VIRTIO_NET_DRV_NAME "virtio-net"
+#define VIRTIO_BLK_DRV_NAME "virtio-blk"
+
+/* Status byte for guest to report progress, and synchronize features */
+
+/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
+#define VIRTIO_CONFIG_S_ACKNOWLEDGE 1
+/* We have found a driver for the device */
+#define VIRTIO_CONFIG_S_DRIVER 2
+/* Driver has used its parts of the config, and is happy */
+#define VIRTIO_CONFIG_S_DRIVER_OK 4
+/* Driver has finished configuring features */
+#define VIRTIO_CONFIG_S_FEATURES_OK 8
+/* Device entered invalid state, driver must reset it */
+#define VIRTIO_CONFIG_S_NEEDS_RESET 0x40
+/* We've given up on this device */
+#define VIRTIO_CONFIG_S_FAILED 0x80
+
+/*
+ * Virtio feature bits VIRTIO_TRANSPORT_F_START through VIRTIO_TRANSPORT_F_END
+ * are reserved for the transport being used (eg: virtio_ring, virtio_pci etc.),
+ * the rest are per-device feature bits.
+ */
+#define VIRTIO_TRANSPORT_F_START 28
+#define VIRTIO_TRANSPORT_F_END 38
+
+#ifndef VIRTIO_CONFIG_NO_LEGACY
+/*
+ * Do we get callbacks when the ring is completely used,
+ * even if we've suppressed them?
+ */
+#define VIRTIO_F_NOTIFY_ON_EMPTY 24
+
+/* Can the device handle any descriptor layout? */
+#define VIRTIO_F_ANY_LAYOUT 27
+#endif /* VIRTIO_CONFIG_NO_LEGACY */
+
+/* v1.0 compliant */
+#define VIRTIO_F_VERSION_1 32
+
+/*
+ * If clear - device has the IOMMU bypass quirk feature.
+ * If set - use platform tools to detect the IOMMU.
+ *
+ * Note the reverse polarity (compared to most other features),
+ * this is for compatibility with legacy systems.
+ */
+#define VIRTIO_F_IOMMU_PLATFORM 33
+
+/* Does the device support Single Root I/O Virtualization? */
+#define VIRTIO_F_SR_IOV 37
+
+/**
+ * virtio scatter-gather struct
+ *
+ * @addr: sg buffer address
+ * @lengh: sg buffer length
+ */
+struct virtio_sg {
+ void *addr;
+ size_t length;
+};
+
+struct virtqueue;
+
+/* virtio bus operations */
+struct dm_virtio_ops {
+ /**
+ * get_config() - read the value of a configuration field
+ *
+ * @vdev: the real virtio device
+ * @offset: the offset of the configuration field
+ * @buf: the buffer to write the field value into
+ * @len: the length of the buffer
+ * @return 0 if OK, -ve on error
+ */
+ int (*get_config)(struct udevice *vdev, unsigned int offset,
+ void *buf, unsigned int len);
+ /**
+ * set_config() - write the value of a configuration field
+ *
+ * @vdev: the real virtio device
+ * @offset: the offset of the configuration field
+ * @buf: the buffer to read the field value from
+ * @len: the length of the buffer
+ * @return 0 if OK, -ve on error
+ */
+ int (*set_config)(struct udevice *vdev, unsigned int offset,
+ const void *buf, unsigned int len);
+ /**
+ * generation() - config generation counter
+ *
+ * @vdev: the real virtio device
+ * @counter: the returned config generation counter
+ * @return 0 if OK, -ve on error
+ */
+ int (*generation)(struct udevice *vdev, u32 *counter);
+ /**
+ * get_status() - read the status byte
+ *
+ * @vdev: the real virtio device
+ * @status: the returned status byte
+ * @return 0 if OK, -ve on error
+ */
+ int (*get_status)(struct udevice *vdev, u8 *status);
+ /**
+ * set_status() - write the status byte
+ *
+ * @vdev: the real virtio device
+ * @status: the new status byte
+ * @return 0 if OK, -ve on error
+ */
+ int (*set_status)(struct udevice *vdev, u8 status);
+ /**
+ * reset() - reset the device
+ *
+ * @vdev: the real virtio device
+ * @return 0 if OK, -ve on error
+ */
+ int (*reset)(struct udevice *vdev);
+ /**
+ * get_features() - get the array of feature bits for this device
+ *
+ * @vdev: the real virtio device
+ * @features: the first 32 feature bits (all we currently need)
+ * @return 0 if OK, -ve on error
+ */
+ int (*get_features)(struct udevice *vdev, u64 *features);
+ /**
+ * set_features() - confirm what device features we'll be using
+ *
+ * @vdev: the real virtio device
+ * @return 0 if OK, -ve on error
+ */
+ int (*set_features)(struct udevice *vdev);
+ /**
+ * find_vqs() - find virtqueues and instantiate them
+ *
+ * @vdev: the real virtio device
+ * @nvqs: the number of virtqueues to find
+ * @vqs: on success, includes new virtqueues
+ * @return 0 if OK, -ve on error
+ */
+ int (*find_vqs)(struct udevice *vdev, unsigned int nvqs,
+ struct virtqueue *vqs[]);
+ /**
+ * del_vqs() - free virtqueues found by find_vqs()
+ *
+ * @vdev: the real virtio device
+ * @return 0 if OK, -ve on error
+ */
+ int (*del_vqs)(struct udevice *vdev);
+ /**
+ * notify() - notify the device to process the queue
+ *
+ * @vdev: the real virtio device
+ * @vq: virtqueue to process
+ * @return 0 if OK, -ve on error
+ */
+ int (*notify)(struct udevice *vdev, struct virtqueue *vq);
+};
+
+/* Get access to a virtio bus' operations */
+#define virtio_get_ops(dev) ((struct dm_virtio_ops *)(dev)->driver->ops)
+
+/**
+ * virtio uclass per device private data
+ *
+ * @vqs: virtualqueue for the virtio device
+ * @vdev: the real virtio device underneath
+ * @legacy: is it a legacy device?
+ * @device: virtio device ID
+ * @vendor: virtio vendor ID
+ * @features: negotiated supported features
+ * @feature_table: an array of feature supported by the driver
+ * @feature_table_size: number of entries in the feature table array
+ * @feature_table_legacy: same as feature_table but working in legacy mode
+ * @feature_table_size_legacy: number of entries in feature table legacy array
+ */
+struct virtio_dev_priv {
+ struct list_head vqs;
+ struct udevice *vdev;
+ bool legacy;
+ u32 device;
+ u32 vendor;
+ u64 features;
+ u32 *feature_table;
+ u32 feature_table_size;
+ u32 *feature_table_legacy;
+ u32 feature_table_size_legacy;
+};
+
+/**
+ * virtio_get_config() - read the value of a configuration field
+ *
+ * @vdev: the real virtio device
+ * @offset: the offset of the configuration field
+ * @buf: the buffer to write the field value into
+ * @len: the length of the buffer
+ * @return 0 if OK, -ve on error
+ */
+int virtio_get_config(struct udevice *vdev, unsigned int offset,
+ void *buf, unsigned int len);
+
+/**
+ * virtio_set_config() - write the value of a configuration field
+ *
+ * @vdev: the real virtio device
+ * @offset: the offset of the configuration field
+ * @buf: the buffer to read the field value from
+ * @len: the length of the buffer
+ * @return 0 if OK, -ve on error
+ */
+int virtio_set_config(struct udevice *vdev, unsigned int offset,
+ void *buf, unsigned int len);
+
+/**
+ * virtio_generation() - config generation counter
+ *
+ * @vdev: the real virtio device
+ * @counter: the returned config generation counter
+ * @return 0 if OK, -ve on error
+ */
+int virtio_generation(struct udevice *vdev, u32 *counter);
+
+/**
+ * virtio_get_status() - read the status byte
+ *
+ * @vdev: the real virtio device
+ * @status: the returned status byte
+ * @return 0 if OK, -ve on error
+ */
+int virtio_get_status(struct udevice *vdev, u8 *status);
+
+/**
+ * virtio_set_status() - write the status byte
+ *
+ * @vdev: the real virtio device
+ * @status: the new status byte
+ * @return 0 if OK, -ve on error
+ */
+int virtio_set_status(struct udevice *vdev, u8 status);
+
+/**
+ * virtio_reset() - reset the device
+ *
+ * @vdev: the real virtio device
+ * @return 0 if OK, -ve on error
+ */
+int virtio_reset(struct udevice *vdev);
+
+/**
+ * virtio_get_features() - get the array of feature bits for this device
+ *
+ * @vdev: the real virtio device
+ * @features: the first 32 feature bits (all we currently need)
+ * @return 0 if OK, -ve on error
+ */
+int virtio_get_features(struct udevice *vdev, u64 *features);
+
+/**
+ * virtio_set_features() - confirm what device features we'll be using
+ *
+ * @vdev: the real virtio device
+ * @return 0 if OK, -ve on error
+ */
+int virtio_set_features(struct udevice *vdev);
+
+/**
+ * virtio_find_vqs() - find virtqueues and instantiate them
+ *
+ * @vdev: the real virtio device
+ * @nvqs: the number of virtqueues to find
+ * @vqs: on success, includes new virtqueues
+ * @return 0 if OK, -ve on error
+ */
+int virtio_find_vqs(struct udevice *vdev, unsigned int nvqs,
+ struct virtqueue *vqs[]);
+
+/**
+ * virtio_del_vqs() - free virtqueues found by find_vqs()
+ *
+ * @vdev: the real virtio device
+ * @return 0 if OK, -ve on error
+ */
+int virtio_del_vqs(struct udevice *vdev);
+
+/**
+ * virtio_notify() - notify the device to process the queue
+ *
+ * @vdev: the real virtio device
+ * @vq: virtqueue to process
+ * @return 0 if OK, -ve on error
+ */
+int virtio_notify(struct udevice *vdev, struct virtqueue *vq);
+
+/**
+ * virtio_add_status() - helper to set a new status code to the device
+ *
+ * @vdev: the real virtio device
+ * @status: new status code to be added
+ */
+void virtio_add_status(struct udevice *vdev, u8 status);
+
+/**
+ * virtio_finalize_features() - helper to finalize features
+ *
+ * @vdev: the real virtio device
+ * @return 0 if OK, -ve on error
+ */
+int virtio_finalize_features(struct udevice *vdev);
+
+/**
+ * virtio_driver_features_init() - initialize driver supported features
+ *
+ * This fills in the virtio device parent per child private data with the given
+ * information, which contains driver supported features and legacy features.
+ *
+ * This API should be called in the virtio device driver's bind method, so that
+ * later virtio transport uclass driver can utilize the driver supplied features
+ * to negotiate with the device on the final supported features.
+ *
+ * @priv: virtio uclass per device private data
+ * @feature: an array of feature supported by the driver
+ * @feature_size: number of entries in the feature table array
+ * @feature_legacy: same as feature_table but working in legacy mode
+ * @feature_legacy_size:number of entries in feature table legacy array
+ */
+void virtio_driver_features_init(struct virtio_dev_priv *priv,
+ u32 *feature, u32 feature_size,
+ u32 *feature_legacy, u32 feature_legacy_size);
+
+/**
+ * virtio_init() - helper to enumerate all known virtio devices
+ */
+void virtio_init(void);
+
+static inline u16 __virtio16_to_cpu(bool little_endian, __virtio16 val)
+{
+ if (little_endian)
+ return le16_to_cpu((__force __le16)val);
+ else
+ return be16_to_cpu((__force __be16)val);
+}
+
+static inline __virtio16 __cpu_to_virtio16(bool little_endian, u16 val)
+{
+ if (little_endian)
+ return (__force __virtio16)cpu_to_le16(val);
+ else
+ return (__force __virtio16)cpu_to_be16(val);
+}
+
+static inline u32 __virtio32_to_cpu(bool little_endian, __virtio32 val)
+{
+ if (little_endian)
+ return le32_to_cpu((__force __le32)val);
+ else
+ return be32_to_cpu((__force __be32)val);
+}
+
+static inline __virtio32 __cpu_to_virtio32(bool little_endian, u32 val)
+{
+ if (little_endian)
+ return (__force __virtio32)cpu_to_le32(val);
+ else
+ return (__force __virtio32)cpu_to_be32(val);
+}
+
+static inline u64 __virtio64_to_cpu(bool little_endian, __virtio64 val)
+{
+ if (little_endian)
+ return le64_to_cpu((__force __le64)val);
+ else
+ return be64_to_cpu((__force __be64)val);
+}
+
+static inline __virtio64 __cpu_to_virtio64(bool little_endian, u64 val)
+{
+ if (little_endian)
+ return (__force __virtio64)cpu_to_le64(val);
+ else
+ return (__force __virtio64)cpu_to_be64(val);
+}
+
+/**
+ * __virtio_test_bit - helper to test feature bits
+ *
+ * For use by transports. Devices should normally use virtio_has_feature,
+ * which includes more checks.
+ *
+ * @udev: the transport device
+ * @fbit: the feature bit
+ */
+static inline bool __virtio_test_bit(struct udevice *udev, unsigned int fbit)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+
+ /* Did you forget to fix assumptions on max features? */
+ if (__builtin_constant_p(fbit))
+ BUILD_BUG_ON(fbit >= 64);
+ else
+ WARN_ON(fbit >= 64);
+
+ return uc_priv->features & BIT_ULL(fbit);
+}
+
+/**
+ * __virtio_set_bit - helper to set feature bits
+ *
+ * For use by transports.
+ *
+ * @udev: the transport device
+ * @fbit: the feature bit
+ */
+static inline void __virtio_set_bit(struct udevice *udev, unsigned int fbit)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+
+ /* Did you forget to fix assumptions on max features? */
+ if (__builtin_constant_p(fbit))
+ BUILD_BUG_ON(fbit >= 64);
+ else
+ WARN_ON(fbit >= 64);
+
+ uc_priv->features |= BIT_ULL(fbit);
+}
+
+/**
+ * __virtio_clear_bit - helper to clear feature bits
+ *
+ * For use by transports.
+ *
+ * @vdev: the transport device
+ * @fbit: the feature bit
+ */
+static inline void __virtio_clear_bit(struct udevice *udev, unsigned int fbit)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+
+ /* Did you forget to fix assumptions on max features? */
+ if (__builtin_constant_p(fbit))
+ BUILD_BUG_ON(fbit >= 64);
+ else
+ WARN_ON(fbit >= 64);
+
+ uc_priv->features &= ~BIT_ULL(fbit);
+}
+
+/**
+ * virtio_has_feature - helper to determine if this device has this feature
+ *
+ * Note this API is only usable after the virtio device driver's bind phase,
+ * as the feature has been negotiated between the device and the driver.
+ *
+ * @vdev: the virtio device
+ * @fbit: the feature bit
+ */
+static inline bool virtio_has_feature(struct udevice *vdev, unsigned int fbit)
+{
+ if (!(vdev->flags & DM_FLAG_BOUND))
+ WARN_ON(true);
+
+ return __virtio_test_bit(vdev->parent, fbit);
+}
+
+static inline bool virtio_legacy_is_little_endian(void)
+{
+#ifdef __LITTLE_ENDIAN
+ return true;
+#else
+ return false;
+#endif
+}
+
+static inline bool virtio_is_little_endian(struct udevice *vdev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
+
+ return !uc_priv->legacy || virtio_legacy_is_little_endian();
+}
+
+/* Memory accessors */
+static inline u16 virtio16_to_cpu(struct udevice *vdev, __virtio16 val)
+{
+ return __virtio16_to_cpu(virtio_is_little_endian(vdev), val);
+}
+
+static inline __virtio16 cpu_to_virtio16(struct udevice *vdev, u16 val)
+{
+ return __cpu_to_virtio16(virtio_is_little_endian(vdev), val);
+}
+
+static inline u32 virtio32_to_cpu(struct udevice *vdev, __virtio32 val)
+{
+ return __virtio32_to_cpu(virtio_is_little_endian(vdev), val);
+}
+
+static inline __virtio32 cpu_to_virtio32(struct udevice *vdev, u32 val)
+{
+ return __cpu_to_virtio32(virtio_is_little_endian(vdev), val);
+}
+
+static inline u64 virtio64_to_cpu(struct udevice *vdev, __virtio64 val)
+{
+ return __virtio64_to_cpu(virtio_is_little_endian(vdev), val);
+}
+
+static inline __virtio64 cpu_to_virtio64(struct udevice *vdev, u64 val)
+{
+ return __cpu_to_virtio64(virtio_is_little_endian(vdev), val);
+}
+
+/* Read @count fields, @bytes each */
+static inline void __virtio_cread_many(struct udevice *vdev,
+ unsigned int offset,
+ void *buf, size_t count, size_t bytes)
+{
+ u32 old, gen;
+ int i;
+
+ virtio_generation(vdev, &gen);
+ do {
+ old = gen;
+
+ for (i = 0; i < count; i++)
+ virtio_get_config(vdev, offset + bytes * i,
+ buf + i * bytes, bytes);
+
+ virtio_generation(vdev, &gen);
+ } while (gen != old);
+}
+
+static inline void virtio_cread_bytes(struct udevice *vdev,
+ unsigned int offset,
+ void *buf, size_t len)
+{
+ __virtio_cread_many(vdev, offset, buf, len, 1);
+}
+
+static inline u8 virtio_cread8(struct udevice *vdev, unsigned int offset)
+{
+ u8 ret;
+
+ virtio_get_config(vdev, offset, &ret, sizeof(ret));
+ return ret;
+}
+
+static inline void virtio_cwrite8(struct udevice *vdev,
+ unsigned int offset, u8 val)
+{
+ virtio_set_config(vdev, offset, &val, sizeof(val));
+}
+
+static inline u16 virtio_cread16(struct udevice *vdev,
+ unsigned int offset)
+{
+ u16 ret;
+
+ virtio_get_config(vdev, offset, &ret, sizeof(ret));
+ return virtio16_to_cpu(vdev, (__force __virtio16)ret);
+}
+
+static inline void virtio_cwrite16(struct udevice *vdev,
+ unsigned int offset, u16 val)
+{
+ val = (__force u16)cpu_to_virtio16(vdev, val);
+ virtio_set_config(vdev, offset, &val, sizeof(val));
+}
+
+static inline u32 virtio_cread32(struct udevice *vdev,
+ unsigned int offset)
+{
+ u32 ret;
+
+ virtio_get_config(vdev, offset, &ret, sizeof(ret));
+ return virtio32_to_cpu(vdev, (__force __virtio32)ret);
+}
+
+static inline void virtio_cwrite32(struct udevice *vdev,
+ unsigned int offset, u32 val)
+{
+ val = (__force u32)cpu_to_virtio32(vdev, val);
+ virtio_set_config(vdev, offset, &val, sizeof(val));
+}
+
+static inline u64 virtio_cread64(struct udevice *vdev,
+ unsigned int offset)
+{
+ u64 ret;
+
+ __virtio_cread_many(vdev, offset, &ret, 1, sizeof(ret));
+ return virtio64_to_cpu(vdev, (__force __virtio64)ret);
+}
+
+static inline void virtio_cwrite64(struct udevice *vdev,
+ unsigned int offset, u64 val)
+{
+ val = (__force u64)cpu_to_virtio64(vdev, val);
+ virtio_set_config(vdev, offset, &val, sizeof(val));
+}
+
+/* Config space read accessor */
+#define virtio_cread(vdev, structname, member, ptr) \
+ do { \
+ /* Must match the member's type, and be integer */ \
+ if (!typecheck(typeof((((structname *)0)->member)), *(ptr))) \
+ (*ptr) = 1; \
+ \
+ switch (sizeof(*ptr)) { \
+ case 1: \
+ *(ptr) = virtio_cread8(vdev, \
+ offsetof(structname, member)); \
+ break; \
+ case 2: \
+ *(ptr) = virtio_cread16(vdev, \
+ offsetof(structname, member)); \
+ break; \
+ case 4: \
+ *(ptr) = virtio_cread32(vdev, \
+ offsetof(structname, member)); \
+ break; \
+ case 8: \
+ *(ptr) = virtio_cread64(vdev, \
+ offsetof(structname, member)); \
+ break; \
+ default: \
+ WARN_ON(true); \
+ } \
+ } while (0)
+
+/* Config space write accessor */
+#define virtio_cwrite(vdev, structname, member, ptr) \
+ do { \
+ /* Must match the member's type, and be integer */ \
+ if (!typecheck(typeof((((structname *)0)->member)), *(ptr))) \
+ WARN_ON((*ptr) == 1); \
+ \
+ switch (sizeof(*ptr)) { \
+ case 1: \
+ virtio_cwrite8(vdev, \
+ offsetof(structname, member), \
+ *(ptr)); \
+ break; \
+ case 2: \
+ virtio_cwrite16(vdev, \
+ offsetof(structname, member), \
+ *(ptr)); \
+ break; \
+ case 4: \
+ virtio_cwrite32(vdev, \
+ offsetof(structname, member), \
+ *(ptr)); \
+ break; \
+ case 8: \
+ virtio_cwrite64(vdev, \
+ offsetof(structname, member), \
+ *(ptr)); \
+ break; \
+ default: \
+ WARN_ON(true); \
+ } \
+ } while (0)
+
+/* Conditional config space accessors */
+#define virtio_cread_feature(vdev, fbit, structname, member, ptr) \
+ ({ \
+ int _r = 0; \
+ if (!virtio_has_feature(vdev, fbit)) \
+ _r = -ENOENT; \
+ else \
+ virtio_cread(vdev, structname, member, ptr); \
+ _r; \
+ })
+
+#endif /* __VIRTIO_H__ */
diff --git a/include/virtio_types.h b/include/virtio_types.h
new file mode 100644
index 0000000..d700d19
--- /dev/null
+++ b/include/virtio_types.h
@@ -0,0 +1,24 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * From Linux kernel include/uapi/linux/virtio_types.h
+ */
+
+#ifndef _LINUX_VIRTIO_TYPES_H
+#define _LINUX_VIRTIO_TYPES_H
+
+#include <linux/types.h>
+
+/*
+ * __virtio{16,32,64} have the following meaning:
+ * - __u{16,32,64} for virtio devices in legacy mode, accessed in native endian
+ * - __le{16,32,64} for standard-compliant virtio devices
+ */
+
+typedef __u16 __bitwise __virtio16;
+typedef __u32 __bitwise __virtio32;
+typedef __u64 __bitwise __virtio64;
+
+#endif /* _LINUX_VIRTIO_TYPES_H */
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
2018-09-23 13:41 ` [U-Boot] [PATCH 01/27] dm: core: Allow uclass to set up a device's child after it is probed Bin Meng
2018-09-23 13:42 ` [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-27 22:11 ` Tuomas Tynkkynen
2018-09-23 13:42 ` [U-Boot] [PATCH 04/27] virtio: Add virtio over mmio transport driver Bin Meng
` (24 subsequent siblings)
27 siblings, 2 replies; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
This adds support for managing virtual queue/ring, the channel
for high performance I/O between host and guest.
Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/virtio/Makefile | 2 +-
drivers/virtio/virtio_ring.c | 356 +++++++++++++++++++++++++++++++++++++++++++
include/virtio_ring.h | 320 ++++++++++++++++++++++++++++++++++++++
3 files changed, 677 insertions(+), 1 deletion(-)
create mode 100644 drivers/virtio/virtio_ring.c
create mode 100644 include/virtio_ring.h
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
index 23e7be7..17d264a 100644
--- a/drivers/virtio/Makefile
+++ b/drivers/virtio/Makefile
@@ -3,4 +3,4 @@
# Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
# Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
-obj-y += virtio-uclass.o
+obj-y += virtio-uclass.o virtio_ring.o
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
new file mode 100644
index 0000000..981b455
--- /dev/null
+++ b/drivers/virtio/virtio_ring.c
@@ -0,0 +1,356 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * virtio ring implementation
+ */
+
+#include <common.h>
+#include <malloc.h>
+#include <virtio.h>
+#include <virtio_ring.h>
+
+int virtqueue_add(struct virtqueue *vq, struct virtio_sg *sgs[],
+ unsigned int out_sgs, unsigned int in_sgs)
+{
+ struct vring_desc *desc;
+ unsigned int total_sg = out_sgs + in_sgs;
+ unsigned int i, n, avail, descs_used, uninitialized_var(prev);
+ int head;
+
+ WARN_ON(total_sg == 0);
+
+ head = vq->free_head;
+
+ desc = vq->vring.desc;
+ i = head;
+ descs_used = total_sg;
+
+ if (vq->num_free < descs_used) {
+ debug("Can't add buf len %i - avail = %i\n",
+ descs_used, vq->num_free);
+ /*
+ * FIXME: for historical reasons, we force a notify here if
+ * there are outgoing parts to the buffer. Presumably the
+ * host should service the ring ASAP.
+ */
+ if (out_sgs)
+ virtio_notify(vq->vdev, vq);
+ return -ENOSPC;
+ }
+
+ for (n = 0; n < out_sgs; n++) {
+ struct virtio_sg *sg = sgs[n];
+
+ desc[i].flags = cpu_to_virtio16(vq->vdev, VRING_DESC_F_NEXT);
+ desc[i].addr = cpu_to_virtio64(vq->vdev, (u64)(size_t)sg->addr);
+ desc[i].len = cpu_to_virtio32(vq->vdev, sg->length);
+
+ prev = i;
+ i = virtio16_to_cpu(vq->vdev, desc[i].next);
+ }
+ for (; n < (out_sgs + in_sgs); n++) {
+ struct virtio_sg *sg = sgs[n];
+
+ desc[i].flags = cpu_to_virtio16(vq->vdev, VRING_DESC_F_NEXT |
+ VRING_DESC_F_WRITE);
+ desc[i].addr = cpu_to_virtio64(vq->vdev,
+ (u64)(uintptr_t)sg->addr);
+ desc[i].len = cpu_to_virtio32(vq->vdev, sg->length);
+
+ prev = i;
+ i = virtio16_to_cpu(vq->vdev, desc[i].next);
+ }
+ /* Last one doesn't continue */
+ desc[prev].flags &= cpu_to_virtio16(vq->vdev, ~VRING_DESC_F_NEXT);
+
+ /* We're using some buffers from the free list. */
+ vq->num_free -= descs_used;
+
+ /* Update free pointer */
+ vq->free_head = i;
+
+ /*
+ * Put entry in available array (but don't update avail->idx
+ * until they do sync).
+ */
+ avail = vq->avail_idx_shadow & (vq->vring.num - 1);
+ vq->vring.avail->ring[avail] = cpu_to_virtio16(vq->vdev, head);
+
+ /*
+ * Descriptors and available array need to be set before we expose the
+ * new available array entries.
+ */
+ virtio_wmb();
+ vq->avail_idx_shadow++;
+ vq->vring.avail->idx = cpu_to_virtio16(vq->vdev, vq->avail_idx_shadow);
+ vq->num_added++;
+
+ /*
+ * This is very unlikely, but theoretically possible.
+ * Kick just in case.
+ */
+ if (unlikely(vq->num_added == (1 << 16) - 1))
+ virtqueue_kick(vq);
+
+ return 0;
+}
+
+static bool virtqueue_kick_prepare(struct virtqueue *vq)
+{
+ u16 new, old;
+ bool needs_kick;
+
+ /*
+ * We need to expose available array entries before checking
+ * avail event.
+ */
+ virtio_mb();
+
+ old = vq->avail_idx_shadow - vq->num_added;
+ new = vq->avail_idx_shadow;
+ vq->num_added = 0;
+
+ if (vq->event) {
+ needs_kick = vring_need_event(virtio16_to_cpu(vq->vdev,
+ vring_avail_event(&vq->vring)), new, old);
+ } else {
+ needs_kick = !(vq->vring.used->flags & cpu_to_virtio16(vq->vdev,
+ VRING_USED_F_NO_NOTIFY));
+ }
+
+ return needs_kick;
+}
+
+void virtqueue_kick(struct virtqueue *vq)
+{
+ if (virtqueue_kick_prepare(vq))
+ virtio_notify(vq->vdev, vq);
+}
+
+static void detach_buf(struct virtqueue *vq, unsigned int head)
+{
+ unsigned int i;
+ __virtio16 nextflag = cpu_to_virtio16(vq->vdev, VRING_DESC_F_NEXT);
+
+ /* Put back on free list: unmap first-level descriptors and find end */
+ i = head;
+
+ while (vq->vring.desc[i].flags & nextflag) {
+ i = virtio16_to_cpu(vq->vdev, vq->vring.desc[i].next);
+ vq->num_free++;
+ }
+
+ vq->vring.desc[i].next = cpu_to_virtio16(vq->vdev, vq->free_head);
+ vq->free_head = head;
+
+ /* Plus final descriptor */
+ vq->num_free++;
+}
+
+static inline bool more_used(const struct virtqueue *vq)
+{
+ return vq->last_used_idx != virtio16_to_cpu(vq->vdev,
+ vq->vring.used->idx);
+}
+
+void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len)
+{
+ unsigned int i;
+ u16 last_used;
+
+ if (!more_used(vq)) {
+ debug("(%s.%d): No more buffers in queue\n",
+ vq->vdev->name, vq->index);
+ return NULL;
+ }
+
+ /* Only get used array entries after they have been exposed by host */
+ virtio_rmb();
+
+ last_used = (vq->last_used_idx & (vq->vring.num - 1));
+ i = virtio32_to_cpu(vq->vdev, vq->vring.used->ring[last_used].id);
+ if (len) {
+ *len = virtio32_to_cpu(vq->vdev,
+ vq->vring.used->ring[last_used].len);
+ debug("(%s.%d): last used idx %u with len %u\n",
+ vq->vdev->name, vq->index, i, *len);
+ }
+
+ if (unlikely(i >= vq->vring.num)) {
+ printf("(%s.%d): id %u out of range\n",
+ vq->vdev->name, vq->index, i);
+ return NULL;
+ }
+
+ detach_buf(vq, i);
+ vq->last_used_idx++;
+ /*
+ * If we expect an interrupt for the next entry, tell host
+ * by writing event index and flush out the write before
+ * the read in the next get_buf call.
+ */
+ if (!(vq->avail_flags_shadow & VRING_AVAIL_F_NO_INTERRUPT))
+ virtio_store_mb(&vring_used_event(&vq->vring),
+ cpu_to_virtio16(vq->vdev, vq->last_used_idx));
+
+ return (void *)(uintptr_t)virtio64_to_cpu(vq->vdev,
+ vq->vring.desc[i].addr);
+}
+
+static struct virtqueue *__vring_new_virtqueue(unsigned int index,
+ struct vring vring,
+ struct udevice *udev)
+{
+ unsigned int i;
+ struct virtqueue *vq;
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+ struct udevice *vdev = uc_priv->vdev;
+
+ vq = malloc(sizeof(*vq));
+ if (!vq)
+ return NULL;
+
+ vq->vdev = vdev;
+ vq->index = index;
+ vq->num_free = vring.num;
+ vq->vring = vring;
+ vq->last_used_idx = 0;
+ vq->avail_flags_shadow = 0;
+ vq->avail_idx_shadow = 0;
+ vq->num_added = 0;
+ list_add_tail(&vq->list, &uc_priv->vqs);
+
+ vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
+
+ /* Tell other side not to bother us */
+ vq->avail_flags_shadow |= VRING_AVAIL_F_NO_INTERRUPT;
+ if (!vq->event)
+ vq->vring.avail->flags = cpu_to_virtio16(vdev,
+ vq->avail_flags_shadow);
+
+ /* Put everything in free lists */
+ vq->free_head = 0;
+ for (i = 0; i < vring.num - 1; i++)
+ vq->vring.desc[i].next = cpu_to_virtio16(vdev, i + 1);
+
+ return vq;
+}
+
+struct virtqueue *vring_create_virtqueue(unsigned int index, unsigned int num,
+ unsigned int vring_align,
+ struct udevice *udev)
+{
+ struct virtqueue *vq;
+ void *queue = NULL;
+ struct vring vring;
+
+ /* We assume num is a power of 2 */
+ if (num & (num - 1)) {
+ printf("Bad virtqueue length %u\n", num);
+ return NULL;
+ }
+
+ /* TODO: allocate each queue chunk individually */
+ for (; num && vring_size(num, vring_align) > PAGE_SIZE; num /= 2) {
+ queue = memalign(PAGE_SIZE, vring_size(num, vring_align));
+ if (queue)
+ break;
+ }
+
+ if (!num)
+ return NULL;
+
+ if (!queue) {
+ /* Try to get a single page. You are my only hope! */
+ queue = memalign(PAGE_SIZE, vring_size(num, vring_align));
+ }
+ if (!queue)
+ return NULL;
+
+ memset(queue, 0, vring_size(num, vring_align));
+ vring_init(&vring, num, queue, vring_align);
+
+ vq = __vring_new_virtqueue(index, vring, udev);
+ if (!vq) {
+ free(queue);
+ return NULL;
+ }
+ debug("(%s): created vring @ %p for vq @ %p with num %u\n", udev->name,
+ queue, vq, num);
+
+ return vq;
+}
+
+void vring_del_virtqueue(struct virtqueue *vq)
+{
+ free(vq->vring.desc);
+ list_del(&vq->list);
+ free(vq);
+}
+
+unsigned int virtqueue_get_vring_size(struct virtqueue *vq)
+{
+ return vq->vring.num;
+}
+
+ulong virtqueue_get_desc_addr(struct virtqueue *vq)
+{
+ return (ulong)vq->vring.desc;
+}
+
+ulong virtqueue_get_avail_addr(struct virtqueue *vq)
+{
+ return (ulong)vq->vring.desc +
+ ((char *)vq->vring.avail - (char *)vq->vring.desc);
+}
+
+ulong virtqueue_get_used_addr(struct virtqueue *vq)
+{
+ return (ulong)vq->vring.desc +
+ ((char *)vq->vring.used - (char *)vq->vring.desc);
+}
+
+bool virtqueue_poll(struct virtqueue *vq, u16 last_used_idx)
+{
+ virtio_mb();
+
+ return last_used_idx != virtio16_to_cpu(vq->vdev, vq->vring.used->idx);
+}
+
+void virtqueue_dump(struct virtqueue *vq)
+{
+ unsigned int i;
+
+ printf("virtqueue %p for dev %s:\n", vq, vq->vdev->name);
+ printf("\tindex %u, phys addr %p num %u\n",
+ vq->index, vq->vring.desc, vq->vring.num);
+ printf("\tfree_head %u, num_added %u, num_free %u\n",
+ vq->free_head, vq->num_added, vq->num_free);
+ printf("\tlast_used_idx %u, avail_flags_shadow %u, avail_idx_shadow %u\n",
+ vq->last_used_idx, vq->avail_flags_shadow, vq->avail_idx_shadow);
+
+ printf("Descriptor dump:\n");
+ for (i = 0; i < vq->vring.num; i++) {
+ printf("\tdesc[%u] = { 0x%llx, len %u, flags %u, next %u }\n",
+ i, vq->vring.desc[i].addr, vq->vring.desc[i].len,
+ vq->vring.desc[i].flags, vq->vring.desc[i].next);
+ }
+
+ printf("Avail ring dump:\n");
+ printf("\tflags %u, idx %u\n",
+ vq->vring.avail->flags, vq->vring.avail->idx);
+ for (i = 0; i < vq->vring.num; i++) {
+ printf("\tavail[%u] = %u\n",
+ i, vq->vring.avail->ring[i]);
+ }
+
+ printf("Used ring dump:\n");
+ printf("\tflags %u, idx %u\n",
+ vq->vring.used->flags, vq->vring.used->idx);
+ for (i = 0; i < vq->vring.num; i++) {
+ printf("\tused[%u] = { %u, %u }\n", i,
+ vq->vring.used->ring[i].id, vq->vring.used->ring[i].len);
+ }
+}
diff --git a/include/virtio_ring.h b/include/virtio_ring.h
new file mode 100644
index 0000000..6fc0593
--- /dev/null
+++ b/include/virtio_ring.h
@@ -0,0 +1,320 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * From Linux kernel include/uapi/linux/virtio_ring.h
+ */
+
+#ifndef _LINUX_VIRTIO_RING_H
+#define _LINUX_VIRTIO_RING_H
+
+#include <virtio_types.h>
+
+/* This marks a buffer as continuing via the next field */
+#define VRING_DESC_F_NEXT 1
+/* This marks a buffer as write-only (otherwise read-only) */
+#define VRING_DESC_F_WRITE 2
+/* This means the buffer contains a list of buffer descriptors */
+#define VRING_DESC_F_INDIRECT 4
+
+/*
+ * The Host uses this in used->flags to advise the Guest: don't kick me when
+ * you add a buffer. It's unreliable, so it's simply an optimization. Guest
+ * will still kick if it's out of buffers.
+ */
+#define VRING_USED_F_NO_NOTIFY 1
+
+/*
+ * The Guest uses this in avail->flags to advise the Host: don't interrupt me
+ * when you consume a buffer. It's unreliable, so it's simply an optimization.
+ */
+#define VRING_AVAIL_F_NO_INTERRUPT 1
+
+/* We support indirect buffer descriptors */
+#define VIRTIO_RING_F_INDIRECT_DESC 28
+
+/*
+ * The Guest publishes the used index for which it expects an interrupt
+ * at the end of the avail ring. Host should ignore the avail->flags field.
+ *
+ * The Host publishes the avail index for which it expects a kick
+ * at the end of the used ring. Guest should ignore the used->flags field.
+ */
+#define VIRTIO_RING_F_EVENT_IDX 29
+
+/* Virtio ring descriptors: 16 bytes. These can chain together via "next". */
+struct vring_desc {
+ /* Address (guest-physical) */
+ __virtio64 addr;
+ /* Length */
+ __virtio32 len;
+ /* The flags as indicated above */
+ __virtio16 flags;
+ /* We chain unused descriptors via this, too */
+ __virtio16 next;
+};
+
+struct vring_avail {
+ __virtio16 flags;
+ __virtio16 idx;
+ __virtio16 ring[];
+};
+
+struct vring_used_elem {
+ /* Index of start of used descriptor chain */
+ __virtio32 id;
+ /* Total length of the descriptor chain which was used (written to) */
+ __virtio32 len;
+};
+
+struct vring_used {
+ __virtio16 flags;
+ __virtio16 idx;
+ struct vring_used_elem ring[];
+};
+
+struct vring {
+ unsigned int num;
+ struct vring_desc *desc;
+ struct vring_avail *avail;
+ struct vring_used *used;
+};
+
+/**
+ * virtqueue - a queue to register buffers for sending or receiving.
+ *
+ * @list: the chain of virtqueues for this device
+ * @vdev: the virtio device this queue was created for
+ * @index: the zero-based ordinal number for this queue
+ * @num_free: number of elements we expect to be able to fit
+ * @vring: actual memory layout for this queue
+ * @event: host publishes avail event idx
+ * @free_head: head of free buffer list
+ * @num_added: number we've added since last sync
+ * @last_used_idx: last used index we've seen
+ * @avail_flags_shadow: last written value to avail->flags
+ * @avail_idx_shadow: last written value to avail->idx in guest byte order
+ */
+struct virtqueue {
+ struct list_head list;
+ struct udevice *vdev;
+ unsigned int index;
+ unsigned int num_free;
+ struct vring vring;
+ bool event;
+ unsigned int free_head;
+ unsigned int num_added;
+ u16 last_used_idx;
+ u16 avail_flags_shadow;
+ u16 avail_idx_shadow;
+};
+
+/*
+ * Alignment requirements for vring elements.
+ * When using pre-virtio 1.0 layout, these fall out naturally.
+ */
+#define VRING_AVAIL_ALIGN_SIZE 2
+#define VRING_USED_ALIGN_SIZE 4
+#define VRING_DESC_ALIGN_SIZE 16
+
+/*
+ * We publish the used event index at the end of the available ring,
+ * and vice versa. They are at the end for backwards compatibility.
+ */
+#define vring_used_event(vr) ((vr)->avail->ring[(vr)->num])
+#define vring_avail_event(vr) (*(__virtio16 *)&(vr)->used->ring[(vr)->num])
+
+static inline void vring_init(struct vring *vr, unsigned int num, void *p,
+ unsigned long align)
+{
+ vr->num = num;
+ vr->desc = p;
+ vr->avail = p + num * sizeof(struct vring_desc);
+ vr->used = (void *)(((uintptr_t)&vr->avail->ring[num] +
+ sizeof(__virtio16) + align - 1) & ~(align - 1));
+}
+
+static inline unsigned int vring_size(unsigned int num, unsigned long align)
+{
+ return ((sizeof(struct vring_desc) * num +
+ sizeof(__virtio16) * (3 + num) + align - 1) & ~(align - 1)) +
+ sizeof(__virtio16) * 3 + sizeof(struct vring_used_elem) * num;
+}
+
+/*
+ * The following is used with USED_EVENT_IDX and AVAIL_EVENT_IDX.
+ * Assuming a given event_idx value from the other side, if we have just
+ * incremented index from old to new_idx, should we trigger an event?
+ */
+static inline int vring_need_event(__u16 event_idx, __u16 new_idx, __u16 old)
+{
+ /*
+ * Note: Xen has similar logic for notification hold-off
+ * in include/xen/interface/io/ring.h with req_event and req_prod
+ * corresponding to event_idx + 1 and new_idx respectively.
+ * Note also that req_event and req_prod in Xen start at 1,
+ * event indexes in virtio start at 0.
+ */
+ return (__u16)(new_idx - event_idx - 1) < (__u16)(new_idx - old);
+}
+
+struct virtio_sg;
+
+/**
+ * virtqueue_add - expose buffers to other end
+ *
+ * @vq: the struct virtqueue we're talking about
+ * @sgs: array of terminated scatterlists
+ * @out_sgs: the number of scatterlists readable by other side
+ * @in_sgs: the number of scatterlists which are writable
+ * (after readable ones)
+ *
+ * Caller must ensure we don't call this with other virtqueue operations
+ * at the same time (except where noted).
+ *
+ * Returns zero or a negative error (ie. ENOSPC, ENOMEM, EIO).
+ */
+int virtqueue_add(struct virtqueue *vq, struct virtio_sg *sgs[],
+ unsigned int out_sgs, unsigned int in_sgs);
+
+/**
+ * virtqueue_kick - update after add_buf
+ *
+ * @vq: the struct virtqueue
+ *
+ * After one or more virtqueue_add() calls, invoke this to kick
+ * the other side.
+ *
+ * Caller must ensure we don't call this with other virtqueue
+ * operations at the same time (except where noted).
+ */
+void virtqueue_kick(struct virtqueue *vq);
+
+/**
+ * virtqueue_get_buf - get the next used buffer
+ *
+ * @vq: the struct virtqueue we're talking about
+ * @len: the length written into the buffer
+ *
+ * If the device wrote data into the buffer, @len will be set to the
+ * amount written. This means you don't need to clear the buffer
+ * beforehand to ensure there's no data leakage in the case of short
+ * writes.
+ *
+ * Caller must ensure we don't call this with other virtqueue
+ * operations at the same time (except where noted).
+ *
+ * Returns NULL if there are no used buffers, or the memory buffer
+ * handed to virtqueue_add_*().
+ */
+void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len);
+
+/**
+ * vring_create_virtqueue - create a virtqueue for a virtio device
+ *
+ * @index: the index of the queue
+ * @num: number of elements of the queue
+ * @vring_align:the alignment requirement of the descriptor ring
+ * @udev: the virtio transport udevice
+ * @return: the virtqueue pointer or NULL if failed
+ *
+ * This creates a virtqueue and allocates the descriptor ring for a virtio
+ * device. The caller should query virtqueue_get_ring_size() to learn the
+ * actual size of the ring.
+ *
+ * This API is supposed to be called by the virtio transport driver in the
+ * virtio find_vqs() uclass method.
+ */
+struct virtqueue *vring_create_virtqueue(unsigned int index, unsigned int num,
+ unsigned int vring_align,
+ struct udevice *udev);
+
+/**
+ * vring_del_virtqueue - destroy a virtqueue
+ *
+ * @vq: the struct virtqueue we're talking about
+ *
+ * This destroys a virtqueue. If created with vring_create_virtqueue(),
+ * this also frees the descriptor ring.
+ *
+ * This API is supposed to be called by the virtio transport driver in the
+ * virtio del_vqs() uclass method.
+ */
+void vring_del_virtqueue(struct virtqueue *vq);
+
+/**
+ * virtqueue_get_vring_size - get the size of the virtqueue's vring
+ *
+ * @vq: the struct virtqueue containing the vring of interest
+ * @return: the size of the vring in a virtqueue.
+ */
+unsigned int virtqueue_get_vring_size(struct virtqueue *vq);
+
+/**
+ * virtqueue_get_desc_addr - get the vring descriptor table address
+ *
+ * @vq: the struct virtqueue containing the vring of interest
+ * @return: the descriptor table address of the vring in a virtqueue.
+ */
+ulong virtqueue_get_desc_addr(struct virtqueue *vq);
+
+/**
+ * virtqueue_get_avail_addr - get the vring available ring address
+ *
+ * @vq: the struct virtqueue containing the vring of interest
+ * @return: the available ring address of the vring in a virtqueue.
+ */
+ulong virtqueue_get_avail_addr(struct virtqueue *vq);
+
+/**
+ * virtqueue_get_used_addr - get the vring used ring address
+ *
+ * @vq: the struct virtqueue containing the vring of interest
+ * @return: the used ring address of the vring in a virtqueue.
+ */
+ulong virtqueue_get_used_addr(struct virtqueue *vq);
+
+/**
+ * virtqueue_poll - query pending used buffers
+ *
+ * @vq: the struct virtqueue we're talking about
+ * @last_used_idx: virtqueue last used index
+ *
+ * Returns "true" if there are pending used buffers in the queue.
+ */
+bool virtqueue_poll(struct virtqueue *vq, u16 last_used_idx);
+
+/**
+ * virtqueue_dump - dump the virtqueue for debugging
+ *
+ * @vq: the struct virtqueue we're talking about
+ *
+ * Caller must ensure we don't call this with other virtqueue operations
+ *@the same time (except where noted).
+ */
+void virtqueue_dump(struct virtqueue *vq);
+
+/*
+ * Barriers in virtio are tricky. Since we are not in a hyperviosr/guest
+ * scenario, having these as nops is enough to work as expected.
+ */
+
+static inline void virtio_mb(void)
+{
+}
+
+static inline void virtio_rmb(void)
+{
+}
+
+static inline void virtio_wmb(void)
+{
+}
+
+static inline void virtio_store_mb(__virtio16 *p, __virtio16 v)
+{
+ WRITE_ONCE(*p, v);
+}
+
+#endif /* _LINUX_VIRTIO_RING_H */
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 04/27] virtio: Add virtio over mmio transport driver
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (2 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 05/27] virtio: Add net driver support Bin Meng
` (23 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
VirtIO can use various different buses and virtio devices are
commonly implemented as PCI devices. But virtual environments
without PCI support (a common situation in embedded devices
models) might use simple memory mapped device (“virtio-mmio”)
instead of the PCI device.
This adds a transport driver that implements UCLASS_VIRTIO for
virtio over mmio.
Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/virtio/Kconfig | 7 +
drivers/virtio/Makefile | 1 +
drivers/virtio/virtio_mmio.c | 413 +++++++++++++++++++++++++++++++++++++++++++
drivers/virtio/virtio_mmio.h | 129 ++++++++++++++
4 files changed, 550 insertions(+)
create mode 100644 drivers/virtio/virtio_mmio.c
create mode 100644 drivers/virtio/virtio_mmio.h
diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
index bdfa96a..60cfaf8 100644
--- a/drivers/virtio/Kconfig
+++ b/drivers/virtio/Kconfig
@@ -11,4 +11,11 @@ config VIRTIO
This option is selected by any driver which implements the virtio
bus, such as CONFIG_VIRTIO_MMIO or CONFIG_VIRTIO_PCI.
+config VIRTIO_MMIO
+ bool "Platform bus driver for memory mapped virtio devices"
+ select VIRTIO
+ help
+ This driver provides support for memory mapped virtio
+ platform device driver.
+
endmenu
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
index 17d264a..2e48785 100644
--- a/drivers/virtio/Makefile
+++ b/drivers/virtio/Makefile
@@ -4,3 +4,4 @@
# Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
obj-y += virtio-uclass.o virtio_ring.o
+obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
new file mode 100644
index 0000000..8038b46
--- /dev/null
+++ b/drivers/virtio/virtio_mmio.c
@@ -0,0 +1,413 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * VirtIO memory-maped I/O transport driver
+ * Ported from Linux drivers/virtio/virtio_mmio.c
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <virtio.h>
+#include <virtio_ring.h>
+#include <dm/device.h>
+#include <linux/compat.h>
+#include <linux/io.h>
+#include "virtio_mmio.h"
+
+static int virtio_mmio_get_config(struct udevice *udev, unsigned int offset,
+ void *buf, unsigned int len)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+ void __iomem *base = priv->base + VIRTIO_MMIO_CONFIG;
+ u8 b;
+ __le16 w;
+ __le32 l;
+
+ if (priv->version == 1) {
+ u8 *ptr = buf;
+ int i;
+
+ for (i = 0; i < len; i++)
+ ptr[i] = readb(base + offset + i);
+
+ return 0;
+ }
+
+ switch (len) {
+ case 1:
+ b = readb(base + offset);
+ memcpy(buf, &b, sizeof(b));
+ break;
+ case 2:
+ w = cpu_to_le16(readw(base + offset));
+ memcpy(buf, &w, sizeof(w));
+ break;
+ case 4:
+ l = cpu_to_le32(readl(base + offset));
+ memcpy(buf, &l, sizeof(l));
+ break;
+ case 8:
+ l = cpu_to_le32(readl(base + offset));
+ memcpy(buf, &l, sizeof(l));
+ l = cpu_to_le32(readl(base + offset + sizeof(l)));
+ memcpy(buf + sizeof(l), &l, sizeof(l));
+ break;
+ default:
+ WARN_ON(true);
+ }
+
+ return 0;
+}
+
+static int virtio_mmio_set_config(struct udevice *udev, unsigned int offset,
+ const void *buf, unsigned int len)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+ void __iomem *base = priv->base + VIRTIO_MMIO_CONFIG;
+ u8 b;
+ __le16 w;
+ __le32 l;
+
+ if (priv->version == 1) {
+ const u8 *ptr = buf;
+ int i;
+
+ for (i = 0; i < len; i++)
+ writeb(ptr[i], base + offset + i);
+
+ return 0;
+ }
+
+ switch (len) {
+ case 1:
+ memcpy(&b, buf, sizeof(b));
+ writeb(b, base + offset);
+ break;
+ case 2:
+ memcpy(&w, buf, sizeof(w));
+ writew(le16_to_cpu(w), base + offset);
+ break;
+ case 4:
+ memcpy(&l, buf, sizeof(l));
+ writel(le32_to_cpu(l), base + offset);
+ break;
+ case 8:
+ memcpy(&l, buf, sizeof(l));
+ writel(le32_to_cpu(l), base + offset);
+ memcpy(&l, buf + sizeof(l), sizeof(l));
+ writel(le32_to_cpu(l), base + offset + sizeof(l));
+ break;
+ default:
+ WARN_ON(true);
+ }
+
+ return 0;
+}
+
+static int virtio_mmio_generation(struct udevice *udev, u32 *counter)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+
+ if (priv->version == 1)
+ *counter = 0;
+ else
+ *counter = readl(priv->base + VIRTIO_MMIO_CONFIG_GENERATION);
+
+ return 0;
+}
+
+static int virtio_mmio_get_status(struct udevice *udev, u8 *status)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+
+ *status = readl(priv->base + VIRTIO_MMIO_STATUS) & 0xff;
+
+ return 0;
+}
+
+static int virtio_mmio_set_status(struct udevice *udev, u8 status)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+
+ /* We should never be setting status to 0 */
+ WARN_ON(status == 0);
+
+ writel(status, priv->base + VIRTIO_MMIO_STATUS);
+
+ return 0;
+}
+
+static int virtio_mmio_reset(struct udevice *udev)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+
+ /* 0 status means a reset */
+ writel(0, priv->base + VIRTIO_MMIO_STATUS);
+
+ return 0;
+}
+
+static int virtio_mmio_get_features(struct udevice *udev, u64 *features)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+
+ writel(1, priv->base + VIRTIO_MMIO_DEVICE_FEATURES_SEL);
+ *features = readl(priv->base + VIRTIO_MMIO_DEVICE_FEATURES);
+ *features <<= 32;
+
+ writel(0, priv->base + VIRTIO_MMIO_DEVICE_FEATURES_SEL);
+ *features |= readl(priv->base + VIRTIO_MMIO_DEVICE_FEATURES);
+
+ return 0;
+}
+
+static int virtio_mmio_set_features(struct udevice *udev)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+
+ /* Make sure there is are no mixed devices */
+ if (priv->version == 2 && uc_priv->legacy) {
+ debug("New virtio-mmio devices (version 2) must provide VIRTIO_F_VERSION_1 feature!\n");
+ return -EINVAL;
+ }
+
+ writel(1, priv->base + VIRTIO_MMIO_DRIVER_FEATURES_SEL);
+ writel((u32)(uc_priv->features >> 32),
+ priv->base + VIRTIO_MMIO_DRIVER_FEATURES);
+
+ writel(0, priv->base + VIRTIO_MMIO_DRIVER_FEATURES_SEL);
+ writel((u32)uc_priv->features,
+ priv->base + VIRTIO_MMIO_DRIVER_FEATURES);
+
+ return 0;
+}
+
+static struct virtqueue *virtio_mmio_setup_vq(struct udevice *udev,
+ unsigned int index)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+ struct virtqueue *vq;
+ unsigned int num;
+ int err;
+
+ /* Select the queue we're interested in */
+ writel(index, priv->base + VIRTIO_MMIO_QUEUE_SEL);
+
+ /* Queue shouldn't already be set up */
+ if (readl(priv->base + (priv->version == 1 ?
+ VIRTIO_MMIO_QUEUE_PFN : VIRTIO_MMIO_QUEUE_READY))) {
+ err = -ENOENT;
+ goto error_available;
+ }
+
+ num = readl(priv->base + VIRTIO_MMIO_QUEUE_NUM_MAX);
+ if (num == 0) {
+ err = -ENOENT;
+ goto error_new_virtqueue;
+ }
+
+ /* Create the vring */
+ vq = vring_create_virtqueue(index, num, VIRTIO_MMIO_VRING_ALIGN, udev);
+ if (!vq) {
+ err = -ENOMEM;
+ goto error_new_virtqueue;
+ }
+
+ /* Activate the queue */
+ writel(virtqueue_get_vring_size(vq),
+ priv->base + VIRTIO_MMIO_QUEUE_NUM);
+ if (priv->version == 1) {
+ u64 q_pfn = virtqueue_get_desc_addr(vq) >> PAGE_SHIFT;
+
+ /*
+ * virtio-mmio v1 uses a 32bit QUEUE PFN. If we have something
+ * that doesn't fit in 32bit, fail the setup rather than
+ * pretending to be successful.
+ */
+ if (q_pfn >> 32) {
+ debug("platform bug: legacy virtio-mmio must not be used with RAM above 0x%llxGB\n",
+ 0x1ULL << (32 + PAGE_SHIFT - 30));
+ err = -E2BIG;
+ goto error_bad_pfn;
+ }
+
+ writel(PAGE_SIZE, priv->base + VIRTIO_MMIO_QUEUE_ALIGN);
+ writel(q_pfn, priv->base + VIRTIO_MMIO_QUEUE_PFN);
+ } else {
+ u64 addr;
+
+ addr = virtqueue_get_desc_addr(vq);
+ writel((u32)addr, priv->base + VIRTIO_MMIO_QUEUE_DESC_LOW);
+ writel((u32)(addr >> 32),
+ priv->base + VIRTIO_MMIO_QUEUE_DESC_HIGH);
+
+ addr = virtqueue_get_avail_addr(vq);
+ writel((u32)addr, priv->base + VIRTIO_MMIO_QUEUE_AVAIL_LOW);
+ writel((u32)(addr >> 32),
+ priv->base + VIRTIO_MMIO_QUEUE_AVAIL_HIGH);
+
+ addr = virtqueue_get_used_addr(vq);
+ writel((u32)addr, priv->base + VIRTIO_MMIO_QUEUE_USED_LOW);
+ writel((u32)(addr >> 32),
+ priv->base + VIRTIO_MMIO_QUEUE_USED_HIGH);
+
+ writel(1, priv->base + VIRTIO_MMIO_QUEUE_READY);
+ }
+
+ return vq;
+
+error_bad_pfn:
+ vring_del_virtqueue(vq);
+
+error_new_virtqueue:
+ if (priv->version == 1) {
+ writel(0, priv->base + VIRTIO_MMIO_QUEUE_PFN);
+ } else {
+ writel(0, priv->base + VIRTIO_MMIO_QUEUE_READY);
+ WARN_ON(readl(priv->base + VIRTIO_MMIO_QUEUE_READY));
+ }
+
+error_available:
+ return ERR_PTR(err);
+}
+
+static void virtio_mmio_del_vq(struct virtqueue *vq)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(vq->vdev);
+ unsigned int index = vq->index;
+
+ /* Select and deactivate the queue */
+ writel(index, priv->base + VIRTIO_MMIO_QUEUE_SEL);
+ if (priv->version == 1) {
+ writel(0, priv->base + VIRTIO_MMIO_QUEUE_PFN);
+ } else {
+ writel(0, priv->base + VIRTIO_MMIO_QUEUE_READY);
+ WARN_ON(readl(priv->base + VIRTIO_MMIO_QUEUE_READY));
+ }
+
+ vring_del_virtqueue(vq);
+}
+
+static int virtio_mmio_del_vqs(struct udevice *udev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+ struct virtqueue *vq, *n;
+
+ list_for_each_entry_safe(vq, n, &uc_priv->vqs, list)
+ virtio_mmio_del_vq(vq);
+
+ return 0;
+}
+
+static int virtio_mmio_find_vqs(struct udevice *udev, unsigned int nvqs,
+ struct virtqueue *vqs[])
+{
+ int i;
+
+ for (i = 0; i < nvqs; ++i) {
+ vqs[i] = virtio_mmio_setup_vq(udev, i);
+ if (IS_ERR(vqs[i])) {
+ virtio_mmio_del_vqs(udev);
+ return PTR_ERR(vqs[i]);
+ }
+ }
+
+ return 0;
+}
+
+static int virtio_mmio_notify(struct udevice *udev, struct virtqueue *vq)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+
+ /*
+ * We write the queue's selector into the notification register
+ * to signal the other end
+ */
+ writel(vq->index, priv->base + VIRTIO_MMIO_QUEUE_NOTIFY);
+
+ return 0;
+}
+
+static int virtio_mmio_ofdata_to_platdata(struct udevice *udev)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+
+ priv->base = (void __iomem *)dev_read_addr(udev);
+ if (priv->base == (void __iomem *)FDT_ADDR_T_NONE)
+ return -EINVAL;
+
+ return 0;
+}
+
+static int virtio_mmio_probe(struct udevice *udev)
+{
+ struct virtio_mmio_priv *priv = dev_get_priv(udev);
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+ u32 magic;
+
+ /* Check magic value */
+ magic = readl(priv->base + VIRTIO_MMIO_MAGIC_VALUE);
+ if (magic != ('v' | 'i' << 8 | 'r' << 16 | 't' << 24)) {
+ debug("(%s): wrong magic value 0x%08x!\n", udev->name, magic);
+ return 0;
+ }
+
+ /* Check device version */
+ priv->version = readl(priv->base + VIRTIO_MMIO_VERSION);
+ if (priv->version < 1 || priv->version > 2) {
+ debug("(%s): version %d not supported!\n",
+ udev->name, priv->version);
+ return 0;
+ }
+
+ /* Check devicd ID */
+ uc_priv->device = readl(priv->base + VIRTIO_MMIO_DEVICE_ID);
+ if (uc_priv->device == 0) {
+ /*
+ * virtio-mmio device with an ID 0 is a (dummy) placeholder
+ * with no function. End probing now with no error reported.
+ */
+ return 0;
+ }
+ uc_priv->vendor = readl(priv->base + VIRTIO_MMIO_VENDOR_ID);
+
+ if (priv->version == 1)
+ writel(PAGE_SIZE, priv->base + VIRTIO_MMIO_GUEST_PAGE_SIZE);
+
+ debug("(%s): device (%d) vendor (%08x) version (%d)\n", udev->name,
+ uc_priv->device, uc_priv->vendor, priv->version);
+
+ return 0;
+}
+
+static const struct dm_virtio_ops virtio_mmio_ops = {
+ .get_config = virtio_mmio_get_config,
+ .set_config = virtio_mmio_set_config,
+ .generation = virtio_mmio_generation,
+ .get_status = virtio_mmio_get_status,
+ .set_status = virtio_mmio_set_status,
+ .reset = virtio_mmio_reset,
+ .get_features = virtio_mmio_get_features,
+ .set_features = virtio_mmio_set_features,
+ .find_vqs = virtio_mmio_find_vqs,
+ .del_vqs = virtio_mmio_del_vqs,
+ .notify = virtio_mmio_notify,
+};
+
+static const struct udevice_id virtio_mmio_ids[] = {
+ { .compatible = "virtio,mmio" },
+ { }
+};
+
+U_BOOT_DRIVER(virtio_mmio) = {
+ .name = "virtio-mmio",
+ .id = UCLASS_VIRTIO,
+ .of_match = virtio_mmio_ids,
+ .ops = &virtio_mmio_ops,
+ .probe = virtio_mmio_probe,
+ .ofdata_to_platdata = virtio_mmio_ofdata_to_platdata,
+ .priv_auto_alloc_size = sizeof(struct virtio_mmio_priv),
+};
diff --git a/drivers/virtio/virtio_mmio.h b/drivers/virtio/virtio_mmio.h
new file mode 100644
index 0000000..b340882
--- /dev/null
+++ b/drivers/virtio/virtio_mmio.h
@@ -0,0 +1,129 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * From Linux kernel include/uapi/linux/virtio_mmio.h
+ */
+
+#ifndef _LINUX_VIRTIO_MMIO_H
+#define _LINUX_VIRTIO_MMIO_H
+
+/* Control registers */
+
+/* Magic value ("virt" string) - Read Only */
+#define VIRTIO_MMIO_MAGIC_VALUE 0x000
+
+/* Virtio device version - Read Only */
+#define VIRTIO_MMIO_VERSION 0x004
+
+/* Virtio device ID - Read Only */
+#define VIRTIO_MMIO_DEVICE_ID 0x008
+
+/* Virtio vendor ID - Read Only */
+#define VIRTIO_MMIO_VENDOR_ID 0x00c
+
+/*
+ * Bitmask of the features supported by the device (host)
+ * (32 bits per set) - Read Only
+ */
+#define VIRTIO_MMIO_DEVICE_FEATURES 0x010
+
+/* Device (host) features set selector - Write Only */
+#define VIRTIO_MMIO_DEVICE_FEATURES_SEL 0x014
+
+/*
+ * Bitmask of features activated by the driver (guest)
+ * (32 bits per set) - Write Only
+ */
+#define VIRTIO_MMIO_DRIVER_FEATURES 0x020
+
+/* Activated features set selector - Write Only */
+#define VIRTIO_MMIO_DRIVER_FEATURES_SEL 0x024
+
+#ifndef VIRTIO_MMIO_NO_LEGACY /* LEGACY DEVICES ONLY! */
+
+/* Guest's memory page size in bytes - Write Only */
+#define VIRTIO_MMIO_GUEST_PAGE_SIZE 0x028
+
+#endif
+
+/* Queue selector - Write Only */
+#define VIRTIO_MMIO_QUEUE_SEL 0x030
+
+/* Maximum size of the currently selected queue - Read Only */
+#define VIRTIO_MMIO_QUEUE_NUM_MAX 0x034
+
+/* Queue size for the currently selected queue - Write Only */
+#define VIRTIO_MMIO_QUEUE_NUM 0x038
+
+#ifndef VIRTIO_MMIO_NO_LEGACY /* LEGACY DEVICES ONLY! */
+
+/* Used Ring alignment for the currently selected queue - Write Only */
+#define VIRTIO_MMIO_QUEUE_ALIGN 0x03c
+
+/* Guest's PFN for the currently selected queue - Read Write */
+#define VIRTIO_MMIO_QUEUE_PFN 0x040
+
+#endif
+
+/* Ready bit for the currently selected queue - Read Write */
+#define VIRTIO_MMIO_QUEUE_READY 0x044
+
+/* Queue notifier - Write Only */
+#define VIRTIO_MMIO_QUEUE_NOTIFY 0x050
+
+/* Interrupt status - Read Only */
+#define VIRTIO_MMIO_INTERRUPT_STATUS 0x060
+
+/* Interrupt acknowledge - Write Only */
+#define VIRTIO_MMIO_INTERRUPT_ACK 0x064
+
+/* Device status register - Read Write */
+#define VIRTIO_MMIO_STATUS 0x070
+
+/* Selected queue's Descriptor Table address, 64 bits in two halves */
+#define VIRTIO_MMIO_QUEUE_DESC_LOW 0x080
+#define VIRTIO_MMIO_QUEUE_DESC_HIGH 0x084
+
+/* Selected queue's Available Ring address, 64 bits in two halves */
+#define VIRTIO_MMIO_QUEUE_AVAIL_LOW 0x090
+#define VIRTIO_MMIO_QUEUE_AVAIL_HIGH 0x094
+
+/* Selected queue's Used Ring address, 64 bits in two halves */
+#define VIRTIO_MMIO_QUEUE_USED_LOW 0x0a0
+#define VIRTIO_MMIO_QUEUE_USED_HIGH 0x0a4
+
+/* Configuration atomicity value */
+#define VIRTIO_MMIO_CONFIG_GENERATION 0x0fc
+
+/*
+ * The config space is defined by each driver as
+ * the per-driver configuration space - Read Write
+ */
+#define VIRTIO_MMIO_CONFIG 0x100
+
+/* Interrupt flags (re: interrupt status & acknowledge registers) */
+
+#define VIRTIO_MMIO_INT_VRING BIT(0)
+#define VIRTIO_MMIO_INT_CONFIG BIT(1)
+
+/*
+ * The alignment to use between consumer and producer parts of vring.
+ * Currently hardcoded to the page size.
+ */
+#define PAGE_SHIFT 12
+#define VIRTIO_MMIO_VRING_ALIGN PAGE_SIZE
+
+/**
+ * virtio mmio transport driver private data
+ *
+ * @base: mmio transport device register base
+ * @version: mmio transport device version
+ */
+struct virtio_mmio_priv {
+ void __iomem *base;
+ u32 version;
+};
+
+#endif /* _LINUX_VIRTIO_MMIO_H */
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 05/27] virtio: Add net driver support
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (3 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 04/27] virtio: Add virtio over mmio transport driver Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
` (2 more replies)
2018-09-23 13:42 ` [U-Boot] [PATCH 06/27] test: dm: blk: Correct blk_base test case Bin Meng
` (22 subsequent siblings)
27 siblings, 3 replies; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
This adds virtio net device driver support.
Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/virtio/Kconfig | 7 ++
drivers/virtio/Makefile | 1 +
drivers/virtio/virtio_net.c | 215 +++++++++++++++++++++++++++++++++++
drivers/virtio/virtio_net.h | 268 ++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 491 insertions(+)
create mode 100644 drivers/virtio/virtio_net.c
create mode 100644 drivers/virtio/virtio_net.h
diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
index 60cfaf8..ceea03a 100644
--- a/drivers/virtio/Kconfig
+++ b/drivers/virtio/Kconfig
@@ -18,4 +18,11 @@ config VIRTIO_MMIO
This driver provides support for memory mapped virtio
platform device driver.
+config VIRTIO_NET
+ bool "virtio net driver"
+ depends on VIRTIO
+ help
+ This is the virtual net driver for virtio. It can be used with
+ QEMU based targets.
+
endmenu
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
index 2e48785..b7764f1 100644
--- a/drivers/virtio/Makefile
+++ b/drivers/virtio/Makefile
@@ -5,3 +5,4 @@
obj-y += virtio-uclass.o virtio_ring.o
obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o
+obj-$(CONFIG_VIRTIO_NET) += virtio_net.o
diff --git a/drivers/virtio/virtio_net.c b/drivers/virtio/virtio_net.c
new file mode 100644
index 0000000..1ab1513
--- /dev/null
+++ b/drivers/virtio/virtio_net.c
@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <net.h>
+#include <virtio.h>
+#include <virtio_ring.h>
+#include "virtio_net.h"
+
+/* Amount of buffers to keep in the RX virtqueue */
+#define VIRTIO_NET_NUM_RX_BUFS 32
+
+/*
+ * This value comes from the VirtIO spec: 1500 for maximum packet size,
+ * 14 for the Ethernet header, 12 for virtio_net_hdr. In total 1526 bytes.
+ */
+#define VIRTIO_NET_RX_BUF_SIZE 1526
+
+struct virtio_net_priv {
+ union {
+ struct virtqueue *vqs[2];
+ struct {
+ struct virtqueue *rx_vq;
+ struct virtqueue *tx_vq;
+ };
+ };
+
+ char rx_buff[VIRTIO_NET_NUM_RX_BUFS][VIRTIO_NET_RX_BUF_SIZE];
+ bool rx_running;
+};
+
+/*
+ * For simplicity, the driver only negotiates the VIRTIO_NET_F_MAC feature.
+ * For the VIRTIO_NET_F_STATUS feature, we don't negotiate it, hence per spec
+ * we should assume the link is always active.
+ */
+static u32 feature[] = {
+ VIRTIO_NET_F_MAC
+};
+
+static u32 feature_legacy[] = {
+ VIRTIO_NET_F_MAC
+};
+
+static int virtio_net_start(struct udevice *dev)
+{
+ struct virtio_net_priv *priv = dev_get_priv(dev);
+ struct virtio_sg sg;
+ struct virtio_sg *sgs[] = { &sg };
+ int i;
+
+ if (!priv->rx_running) {
+ /* receive buffer length is always 1526 */
+ sg.length = VIRTIO_NET_RX_BUF_SIZE;
+
+ /* setup the receive buffer address */
+ for (i = 0; i < VIRTIO_NET_NUM_RX_BUFS; i++) {
+ sg.addr = priv->rx_buff[i];
+ virtqueue_add(priv->rx_vq, sgs, 0, 1);
+ }
+
+ virtqueue_kick(priv->rx_vq);
+
+ /* setup the receive queue only once */
+ priv->rx_running = true;
+ }
+
+ return 0;
+}
+
+static int virtio_net_send(struct udevice *dev, void *packet, int length)
+{
+ struct virtio_net_priv *priv = dev_get_priv(dev);
+ struct virtio_net_hdr hdr;
+ struct virtio_sg hdr_sg = { &hdr, sizeof(hdr) };
+ struct virtio_sg data_sg = { packet, length };
+ struct virtio_sg *sgs[] = { &hdr_sg, &data_sg };
+ int ret;
+
+ memset(&hdr, 0, sizeof(struct virtio_net_hdr));
+
+ ret = virtqueue_add(priv->tx_vq, sgs, 2, 0);
+ if (ret)
+ return ret;
+
+ virtqueue_kick(priv->tx_vq);
+
+ while (1) {
+ if (virtqueue_get_buf(priv->tx_vq, NULL))
+ break;
+ }
+
+ return 0;
+}
+
+static int virtio_net_recv(struct udevice *dev, int flags, uchar **packetp)
+{
+ struct virtio_net_priv *priv = dev_get_priv(dev);
+ unsigned int len;
+ void *buf;
+
+ buf = virtqueue_get_buf(priv->rx_vq, &len);
+ if (!buf)
+ return -EAGAIN;
+
+ *packetp = buf + sizeof(struct virtio_net_hdr);
+ return len - sizeof(struct virtio_net_hdr);
+}
+
+static int virtio_net_free_pkt(struct udevice *dev, uchar *packet, int length)
+{
+ struct virtio_net_priv *priv = dev_get_priv(dev);
+ void *buf = packet - sizeof(struct virtio_net_hdr);
+ struct virtio_sg sg = { buf, VIRTIO_NET_RX_BUF_SIZE };
+ struct virtio_sg *sgs[] = { &sg };
+
+ /* Put the buffer back to the rx ring */
+ virtqueue_add(priv->rx_vq, sgs, 0, 1);
+
+ return 0;
+}
+
+static void virtio_net_stop(struct udevice *dev)
+{
+ /*
+ * There is no way to stop the queue from running, unless we issue
+ * a reset to the virtio device, and re-do the queue initialization
+ * from the beginning.
+ */
+}
+
+static int virtio_net_write_hwaddr(struct udevice *dev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(dev->parent);
+ struct eth_pdata *pdata = dev_get_platdata(dev);
+ int i;
+
+ /*
+ * v1.0 compliant device's MAC address is set through control channel,
+ * which we don't support for now.
+ */
+ if (!uc_priv->legacy)
+ return -ENOSYS;
+
+ for (i = 0; i < sizeof(pdata->enetaddr); i++) {
+ virtio_cwrite8(dev,
+ offsetof(struct virtio_net_config, mac) + i,
+ pdata->enetaddr[i]);
+ }
+
+ return 0;
+}
+
+static int virtio_net_read_rom_hwaddr(struct udevice *dev)
+{
+ struct eth_pdata *pdata = dev_get_platdata(dev);
+
+ if (!pdata)
+ return -ENOSYS;
+
+ if (virtio_has_feature(dev, VIRTIO_NET_F_MAC)) {
+ virtio_cread_bytes(dev,
+ offsetof(struct virtio_net_config, mac),
+ pdata->enetaddr, sizeof(pdata->enetaddr));
+ }
+
+ return 0;
+}
+
+static int virtio_net_bind(struct udevice *dev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(dev->parent);
+
+ /* Indicate what driver features we support */
+ virtio_driver_features_init(uc_priv, feature, ARRAY_SIZE(feature),
+ feature_legacy, ARRAY_SIZE(feature_legacy));
+
+ return 0;
+}
+
+static int virtio_net_probe(struct udevice *dev)
+{
+ struct virtio_net_priv *priv = dev_get_priv(dev);
+ int ret;
+
+ ret = virtio_find_vqs(dev, 2, priv->vqs);
+ if (ret < 0)
+ return ret;
+
+ return 0;
+}
+
+static const struct eth_ops virtio_net_ops = {
+ .start = virtio_net_start,
+ .send = virtio_net_send,
+ .recv = virtio_net_recv,
+ .free_pkt = virtio_net_free_pkt,
+ .stop = virtio_net_stop,
+ .write_hwaddr = virtio_net_write_hwaddr,
+ .read_rom_hwaddr = virtio_net_read_rom_hwaddr,
+};
+
+U_BOOT_DRIVER(virtio_net) = {
+ .name = VIRTIO_NET_DRV_NAME,
+ .id = UCLASS_ETH,
+ .bind = virtio_net_bind,
+ .probe = virtio_net_probe,
+ .ops = &virtio_net_ops,
+ .priv_auto_alloc_size = sizeof(struct virtio_net_priv),
+ .platdata_auto_alloc_size = sizeof(struct eth_pdata),
+};
diff --git a/drivers/virtio/virtio_net.h b/drivers/virtio/virtio_net.h
new file mode 100644
index 0000000..c92bae5
--- /dev/null
+++ b/drivers/virtio/virtio_net.h
@@ -0,0 +1,268 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * From Linux kernel include/uapi/linux/virtio_net.h
+ */
+
+#ifndef _LINUX_VIRTIO_NET_H
+#define _LINUX_VIRTIO_NET_H
+
+/* TODO: needs to be removed! */
+#define ETH_ALEN 6
+
+/* The feature bitmap for virtio net */
+
+/* Host handles pkts w/ partial csum */
+#define VIRTIO_NET_F_CSUM 0
+/* Guest handles pkts w/ partial csum */
+#define VIRTIO_NET_F_GUEST_CSUM 1
+/* Dynamic offload configuration */
+#define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 2
+/* Initial MTU advice */
+#define VIRTIO_NET_F_MTU 3
+/* Host has given MAC address */
+#define VIRTIO_NET_F_MAC 5
+/* Guest can handle TSOv4 in */
+#define VIRTIO_NET_F_GUEST_TSO4 7
+/* Guest can handle TSOv6 in */
+#define VIRTIO_NET_F_GUEST_TSO6 8
+/* Guest can handle TSO[6] w/ ECN in */
+#define VIRTIO_NET_F_GUEST_ECN 9
+/* Guest can handle UFO in */
+#define VIRTIO_NET_F_GUEST_UFO 10
+/* Host can handle TSOv4 in */
+#define VIRTIO_NET_F_HOST_TSO4 11
+/* Host can handle TSOv6 in */
+#define VIRTIO_NET_F_HOST_TSO6 12
+/* Host can handle TSO[6] w/ ECN in */
+#define VIRTIO_NET_F_HOST_ECN 13
+/* Host can handle UFO in */
+#define VIRTIO_NET_F_HOST_UFO 14
+/* Host can merge receive buffers */
+#define VIRTIO_NET_F_MRG_RXBUF 15
+/* virtio_net_config.status available */
+#define VIRTIO_NET_F_STATUS 16
+/* Control channel available */
+#define VIRTIO_NET_F_CTRL_VQ 17
+/* Control channel RX mode support */
+#define VIRTIO_NET_F_CTRL_RX 18
+/* Control channel VLAN filtering */
+#define VIRTIO_NET_F_CTRL_VLAN 19
+/* Extra RX mode control support */
+#define VIRTIO_NET_F_CTRL_RX_EXTRA 20
+/* Guest can announce device on the network */
+#define VIRTIO_NET_F_GUEST_ANNOUNCE 21
+/* Device supports receive flow steering */
+#define VIRTIO_NET_F_MQ 22
+/* Set MAC address */
+#define VIRTIO_NET_F_CTRL_MAC_ADDR 23
+/* Device set linkspeed and duplex */
+#define VIRTIO_NET_F_SPEED_DUPLEX 63
+
+#ifndef VIRTIO_NET_NO_LEGACY
+/* Host handles pkts w/ any GSO type */
+#define VIRTIO_NET_F_GSO 6
+#endif /* VIRTIO_NET_NO_LEGACY */
+
+#define VIRTIO_NET_S_LINK_UP 1 /* Link is up */
+#define VIRTIO_NET_S_ANNOUNCE 2 /* Announcement is needed */
+
+struct __packed virtio_net_config {
+ /* The config defining mac address (if VIRTIO_NET_F_MAC) */
+ __u8 mac[ETH_ALEN];
+ /* See VIRTIO_NET_F_STATUS and VIRTIO_NET_S_* above */
+ __u16 status;
+ /*
+ * Maximum number of each of transmit and receive queues;
+ * see VIRTIO_NET_F_MQ and VIRTIO_NET_CTRL_MQ.
+ * Legal values are between 1 and 0x8000
+ */
+ __u16 max_virtqueue_pairs;
+ /* Default maximum transmit unit advice */
+ __u16 mtu;
+ /*
+ * speed, in units of 1Mb. All values 0 to INT_MAX are legal.
+ * Any other value stands for unknown.
+ */
+ __u32 speed;
+ /*
+ * 0x00 - half duplex
+ * 0x01 - full duplex
+ * Any other value stands for unknown.
+ */
+ __u8 duplex;
+};
+
+/*
+ * This header comes first in the scatter-gather list. If you don't
+ * specify GSO or CSUM features, you can simply ignore the header.
+ *
+ * This is bitwise-equivalent to the legacy struct virtio_net_hdr_mrg_rxbuf,
+ * only flattened.
+ */
+struct virtio_net_hdr_v1 {
+#define VIRTIO_NET_HDR_F_NEEDS_CSUM 0x01 /* Use csum_start, csum_offset */
+#define VIRTIO_NET_HDR_F_DATA_VALID 0x02 /* Csum is valid */
+ __u8 flags;
+#define VIRTIO_NET_HDR_GSO_NONE 0x00 /* Not a GSO frame */
+#define VIRTIO_NET_HDR_GSO_TCPV4 0x01 /* GSO frame, IPv4 TCP (TSO) */
+#define VIRTIO_NET_HDR_GSO_UDP 0x03 /* GSO frame, IPv4 UDP (UFO) */
+#define VIRTIO_NET_HDR_GSO_TCPV6 0x04 /* GSO frame, IPv6 TCP */
+#define VIRTIO_NET_HDR_GSO_ECN 0x80 /* TCP has ECN set */
+ __u8 gso_type;
+ __virtio16 hdr_len; /* Ethernet + IP + tcp/udp hdrs */
+ __virtio16 gso_size; /* Bytes to append to hdr_len per frame */
+ __virtio16 csum_start; /* Position to start checksumming from */
+ __virtio16 csum_offset; /* Offset after that to place checksum */
+ __virtio16 num_buffers; /* Number of merged rx buffers */
+};
+
+#ifndef VIRTIO_NET_NO_LEGACY
+/*
+ * This header comes first in the scatter-gather list.
+ *
+ * For legacy virtio, if VIRTIO_F_ANY_LAYOUT is not negotiated, it must
+ * be the first element of the scatter-gather list. If you don't
+ * specify GSO or CSUM features, you can simply ignore the header.
+ */
+struct virtio_net_hdr {
+ /* See VIRTIO_NET_HDR_F_* */
+ __u8 flags;
+ /* See VIRTIO_NET_HDR_GSO_* */
+ __u8 gso_type;
+ __virtio16 hdr_len; /* Ethernet + IP + tcp/udp hdrs */
+ __virtio16 gso_size; /* Bytes to append to hdr_len per frame */
+ __virtio16 csum_start; /* Position to start checksumming from */
+ __virtio16 csum_offset; /* Offset after that to place checksum */
+};
+
+/*
+ * This is the version of the header to use when the MRG_RXBUF
+ * feature has been negotiated.
+ */
+struct virtio_net_hdr_mrg_rxbuf {
+ struct virtio_net_hdr hdr;
+ __virtio16 num_buffers; /* Number of merged rx buffers */
+};
+#endif /* ...VIRTIO_NET_NO_LEGACY */
+
+/*
+ * Control virtqueue data structures
+ *
+ * The control virtqueue expects a header in the first sg entry
+ * and an ack/status response in the last entry. Data for the
+ * command goes in between.
+ */
+struct __packed virtio_net_ctrl_hdr {
+ __u8 class;
+ __u8 cmd;
+};
+
+typedef __u8 virtio_net_ctrl_ack;
+
+#define VIRTIO_NET_OK 0
+#define VIRTIO_NET_ERR 1
+
+/*
+ * Control the RX mode, ie. promisucous, allmulti, etc...
+ *
+ * All commands require an "out" sg entry containing a 1 byte state value,
+ * zero = disable, non-zero = enable.
+ *
+ * Commands 0 and 1 are supported with the VIRTIO_NET_F_CTRL_RX feature.
+ * Commands 2-5 are added with VIRTIO_NET_F_CTRL_RX_EXTRA.
+ */
+#define VIRTIO_NET_CTRL_RX 0
+#define VIRTIO_NET_CTRL_RX_PROMISC 0
+#define VIRTIO_NET_CTRL_RX_ALLMULTI 1
+#define VIRTIO_NET_CTRL_RX_ALLUNI 2
+#define VIRTIO_NET_CTRL_RX_NOMULTI 3
+#define VIRTIO_NET_CTRL_RX_NOUNI 4
+#define VIRTIO_NET_CTRL_RX_NOBCAST 5
+
+/*
+ * Control the MAC
+ *
+ * The MAC filter table is managed by the hypervisor, the guest should assume
+ * the size is infinite. Filtering should be considered non-perfect, ie. based
+ * on hypervisor resources, the guest may received packets from sources not
+ * specified in the filter list.
+ *
+ * In addition to the class/cmd header, the TABLE_SET command requires two
+ * out scatterlists. Each contains a 4 byte count of entries followed by a
+ * concatenated byte stream of the ETH_ALEN MAC addresses. The first sg list
+ * contains unicast addresses, the second is for multicast. This functionality
+ * is present if the VIRTIO_NET_F_CTRL_RX feature is available.
+ *
+ * The ADDR_SET command requests one out scatterlist, it contains a 6 bytes MAC
+ * address. This functionality is present if the VIRTIO_NET_F_CTRL_MAC_ADDR
+ * feature is available.
+ */
+struct __packed virtio_net_ctrl_mac {
+ __virtio32 entries;
+ __u8 macs[][ETH_ALEN];
+};
+
+#define VIRTIO_NET_CTRL_MAC 1
+#define VIRTIO_NET_CTRL_MAC_TABLE_SET 0
+#define VIRTIO_NET_CTRL_MAC_ADDR_SET 1
+
+/*
+ * Control VLAN filtering
+ *
+ * The VLAN filter table is controlled via a simple ADD/DEL interface. VLAN IDs
+ * not added may be filterd by the hypervisor. Del is the opposite of add. Both
+ * commands expect an out entry containing a 2 byte VLAN ID. VLAN filterting is
+ * available with the VIRTIO_NET_F_CTRL_VLAN feature bit.
+ */
+#define VIRTIO_NET_CTRL_VLAN 2
+#define VIRTIO_NET_CTRL_VLAN_ADD 0
+#define VIRTIO_NET_CTRL_VLAN_DEL 1
+
+/*
+ * Control link announce acknowledgment
+ *
+ * The command VIRTIO_NET_CTRL_ANNOUNCE_ACK is used to indicate that driver has
+ * recevied the notification; device would clear the VIRTIO_NET_S_ANNOUNCE bit
+ * in the status field after it receives this command.
+ */
+#define VIRTIO_NET_CTRL_ANNOUNCE 3
+#define VIRTIO_NET_CTRL_ANNOUNCE_ACK 0
+
+/*
+ * Control receive flow steering
+ *
+ * The command VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET enables receive flow steering,
+ * specifying the number of the transmit and receive queues that will be used.
+ * After the command is consumed and acked by the device, the device will not
+ * steer new packets on receive virtqueues other than specified nor read from
+ * transmit virtqueues other than specified. Accordingly, driver should not
+ * transmit new packets on virtqueues other than specified.
+ */
+struct virtio_net_ctrl_mq {
+ __virtio16 virtqueue_pairs;
+};
+
+#define VIRTIO_NET_CTRL_MQ 4
+#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET 0
+#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN 1
+#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX 0x8000
+
+/*
+ * Control network offloads
+ *
+ * Reconfigures the network offloads that guest can handle.
+ *
+ * Available with the VIRTIO_NET_F_CTRL_GUEST_OFFLOADS feature bit.
+ *
+ * Command data format matches the feature bit mask exactly.
+ *
+ * See VIRTIO_NET_F_GUEST_* for the list of offloads
+ * that can be enabled/disabled.
+ */
+#define VIRTIO_NET_CTRL_GUEST_OFFLOADS 5
+#define VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET 0
+
+#endif /* _LINUX_VIRTIO_NET_H */
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 06/27] test: dm: blk: Correct blk_base test case
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (4 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 05/27] virtio: Add net driver support Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 07/27] sandbox: blk: Switch to use platdata_auto_alloc_size for the driver data Bin Meng
` (21 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
The blk_base test case creates a USB mass storage block device with
the Sandbox host block device as its parent. This does not make any
sense and causes potential issue, for example if the test case tries
to read/write anything on the USB mass storage block device it will
definitely fail as its parent is not on USB bus at all.
Correct the test case by creating another Sandbox host block device
instead of the USB mass storage one and adjust the case accordingly.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
test/dm/blk.c | 27 +++++++++++----------------
1 file changed, 11 insertions(+), 16 deletions(-)
diff --git a/test/dm/blk.c b/test/dm/blk.c
index 4de477b..9c71adc 100644
--- a/test/dm/blk.c
+++ b/test/dm/blk.c
@@ -15,34 +15,29 @@ DECLARE_GLOBAL_DATA_PTR;
/* Test that block devices can be created */
static int dm_test_blk_base(struct unit_test_state *uts)
{
- struct udevice *blk, *usb_blk, *dev;
+ struct udevice *blk1, *blk3, *dev;
/* Make sure there are no block devices */
- ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_BLK, 0, &blk));
+ ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_BLK, 0, &dev));
/* Create two, one the parent of the other */
ut_assertok(blk_create_device(gd->dm_root, "sandbox_host_blk", "test",
- IF_TYPE_HOST, 1, 512, 2, &blk));
- ut_assertok(blk_create_device(blk, "usb_storage_blk", "test",
- IF_TYPE_USB, 3, 512, 2, &usb_blk));
+ IF_TYPE_HOST, 1, 512, 2, &blk1));
+ ut_assertok(blk_create_device(blk1, "sandbox_host_blk", "test",
+ IF_TYPE_HOST, 3, 512, 2, &blk3));
/* Check we can find them */
ut_asserteq(-ENODEV, blk_get_device(IF_TYPE_HOST, 0, &dev));
ut_assertok(blk_get_device(IF_TYPE_HOST, 1, &dev));
- ut_asserteq_ptr(blk, dev);
-
- ut_asserteq(-ENODEV, blk_get_device(IF_TYPE_USB, 0, &dev));
- ut_assertok(blk_get_device(IF_TYPE_USB, 3, &dev));
- ut_asserteq_ptr(usb_blk, dev);
+ ut_asserteq_ptr(blk1, dev);
+ ut_assertok(blk_get_device(IF_TYPE_HOST, 3, &dev));
+ ut_asserteq_ptr(blk3, dev);
/* Check we can iterate */
ut_assertok(blk_first_device(IF_TYPE_HOST, &dev));
- ut_asserteq_ptr(blk, dev);
- ut_asserteq(-ENODEV, blk_next_device(&dev));
-
- ut_assertok(blk_first_device(IF_TYPE_USB, &dev));
- ut_asserteq_ptr(usb_blk, dev);
- ut_asserteq(-ENODEV, blk_next_device(&dev));
+ ut_asserteq_ptr(blk1, dev);
+ ut_assertok(blk_next_device(&dev));
+ ut_asserteq_ptr(blk3, dev);
return 0;
}
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 07/27] sandbox: blk: Switch to use platdata_auto_alloc_size for the driver data
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (5 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 06/27] test: dm: blk: Correct blk_base test case Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 08/27] efi_driver: " Bin Meng
` (20 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
Currently the sandbox block driver uses priv_auto_alloc_size for
the driver data, however that's only available after the device
probe phase. In order to make it accessible in an earlier phase,
switch to use platdata_auto_alloc_size instead.
This patch is the prerequisite for the follow up patch of DM BLK
driver changes to work with Sandbox.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/block/sandbox.c | 15 ++++++++-------
1 file changed, 8 insertions(+), 7 deletions(-)
diff --git a/drivers/block/sandbox.c b/drivers/block/sandbox.c
index 0392437..576d049 100644
--- a/drivers/block/sandbox.c
+++ b/drivers/block/sandbox.c
@@ -33,7 +33,7 @@ static unsigned long host_block_read(struct udevice *dev,
unsigned long start, lbaint_t blkcnt,
void *buffer)
{
- struct host_block_dev *host_dev = dev_get_priv(dev);
+ struct host_block_dev *host_dev = dev_get_platdata(dev);
struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
#else
@@ -64,7 +64,7 @@ static unsigned long host_block_write(struct udevice *dev,
unsigned long start, lbaint_t blkcnt,
const void *buffer)
{
- struct host_block_dev *host_dev = dev_get_priv(dev);
+ struct host_block_dev *host_dev = dev_get_platdata(dev);
struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
#else
static unsigned long host_block_write(struct blk_desc *block_dev,
@@ -131,16 +131,17 @@ int host_dev_bind(int devnum, char *filename)
os_lseek(fd, 0, OS_SEEK_END) / 512, &dev);
if (ret)
goto err_file;
+
+ host_dev = dev_get_platdata(dev);
+ host_dev->fd = fd;
+ host_dev->filename = fname;
+
ret = device_probe(dev);
if (ret) {
device_unbind(dev);
goto err_file;
}
- host_dev = dev_get_priv(dev);
- host_dev->fd = fd;
- host_dev->filename = fname;
-
return blk_prepare_device(dev);
err_file:
os_close(fd);
@@ -226,7 +227,7 @@ U_BOOT_DRIVER(sandbox_host_blk) = {
.name = "sandbox_host_blk",
.id = UCLASS_BLK,
.ops = &sandbox_host_blk_ops,
- .priv_auto_alloc_size = sizeof(struct host_block_dev),
+ .platdata_auto_alloc_size = sizeof(struct host_block_dev),
};
#else
U_BOOT_LEGACY_BLK(sandbox_host) = {
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 08/27] efi_driver: blk: Switch to use platdata_auto_alloc_size for the driver data
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (6 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 07/27] sandbox: blk: Switch to use platdata_auto_alloc_size for the driver data Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 09/27] blk: Call part_init() in the post_probe() method Bin Meng
` (19 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
Currently the efi block driver uses priv_auto_alloc_size for the
driver data, however that's only available after the device probe
phase. In order to make it accessible in an earlier phase, switch
to use platdata_auto_alloc_size instead.
This patch is the prerequisite for the follow up patch of DM BLK
driver changes to work with EFI loader.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
lib/efi_driver/efi_block_device.c | 24 ++++++++++++------------
1 file changed, 12 insertions(+), 12 deletions(-)
diff --git a/lib/efi_driver/efi_block_device.c b/lib/efi_driver/efi_block_device.c
index 5b9c139..7b71b4d 100644
--- a/lib/efi_driver/efi_block_device.c
+++ b/lib/efi_driver/efi_block_device.c
@@ -38,7 +38,7 @@
* handle handle of the controller on which this driver is installed
* io block io protocol proxied by this driver
*/
-struct efi_blk_priv {
+struct efi_blk_platdata {
efi_handle_t handle;
struct efi_block_io *io;
};
@@ -55,8 +55,8 @@ struct efi_blk_priv {
static ulong efi_bl_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
void *buffer)
{
- struct efi_blk_priv *priv = dev->priv;
- struct efi_block_io *io = priv->io;
+ struct efi_blk_platdata *platdata = dev_get_platdata(dev);
+ struct efi_block_io *io = platdata->io;
efi_status_t ret;
EFI_PRINT("%s: read '%s', from block " LBAFU ", " LBAFU " blocks\n",
@@ -84,8 +84,8 @@ static ulong efi_bl_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
static ulong efi_bl_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
const void *buffer)
{
- struct efi_blk_priv *priv = dev->priv;
- struct efi_block_io *io = priv->io;
+ struct efi_blk_platdata *platdata = dev_get_platdata(dev);
+ struct efi_block_io *io = platdata->io;
efi_status_t ret;
EFI_PRINT("%s: write '%s', from block " LBAFU ", " LBAFU " blocks\n",
@@ -135,7 +135,7 @@ static int efi_bl_bind(efi_handle_t handle, void *interface)
struct efi_object *obj = efi_search_obj(handle);
struct efi_block_io *io = interface;
int disks;
- struct efi_blk_priv *priv;
+ struct efi_blk_platdata *platdata;
EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io);
@@ -163,16 +163,16 @@ static int efi_bl_bind(efi_handle_t handle, void *interface)
return -ENOENT;
/* Set the DM_FLAG_NAME_ALLOCED flag to avoid a memory leak */
device_set_name_alloced(bdev);
- /* Allocate priv */
+
+ platdata = dev_get_platdata(bdev);
+ platdata->handle = handle;
+ platdata->io = interface;
+
ret = device_probe(bdev);
if (ret)
return ret;
EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
- priv = bdev->priv;
- priv->handle = handle;
- priv->io = interface;
-
ret = blk_prepare_device(bdev);
/* Create handles for the partions of the block device */
@@ -193,7 +193,7 @@ U_BOOT_DRIVER(efi_blk) = {
.name = "efi_blk",
.id = UCLASS_BLK,
.ops = &efi_blk_ops,
- .priv_auto_alloc_size = sizeof(struct efi_blk_priv),
+ .platdata_auto_alloc_size = sizeof(struct efi_blk_platdata),
};
/* EFI driver operators */
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 09/27] blk: Call part_init() in the post_probe() method
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (7 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 08/27] efi_driver: " Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 10/27] blk: Drop blk_prepare_device() Bin Meng
` (18 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
part_init() is currently called in every DM BLK driver, either
in its bind() or probe() method. However we can use the BLK
uclass driver's post_probe() method to do it automatically.
Update all DM BLK drivers to adopt this change.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
cmd/sata.c | 9 ---------
common/usb_storage.c | 4 +---
drivers/block/blk-uclass.c | 12 ++++++++++++
drivers/block/ide.c | 2 --
drivers/block/sandbox.c | 2 +-
drivers/mmc/mmc.c | 3 ---
drivers/nvme/nvme.c | 1 -
drivers/scsi/scsi.c | 1 -
lib/efi_driver/efi_block_device.c | 2 --
9 files changed, 14 insertions(+), 22 deletions(-)
diff --git a/cmd/sata.c b/cmd/sata.c
index 4f0c6e0..6d62ba8 100644
--- a/cmd/sata.c
+++ b/cmd/sata.c
@@ -51,7 +51,6 @@ int sata_probe(int devnum)
{
#ifdef CONFIG_AHCI
struct udevice *dev;
- struct udevice *blk;
int rc;
rc = uclass_get_device(UCLASS_AHCI, devnum, &dev);
@@ -67,14 +66,6 @@ int sata_probe(int devnum)
return CMD_RET_FAILURE;
}
- rc = blk_get_from_parent(dev, &blk);
- if (!rc) {
- struct blk_desc *desc = dev_get_uclass_platdata(blk);
-
- if (desc->lba > 0 && desc->blksz > 0)
- part_init(desc);
- }
-
return 0;
#else
return sata_initialize() < 0 ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
diff --git a/common/usb_storage.c b/common/usb_storage.c
index d92ebb6..560d605 100644
--- a/common/usb_storage.c
+++ b/common/usb_storage.c
@@ -226,9 +226,7 @@ static int usb_stor_probe_device(struct usb_device *udev)
blkdev->lun = lun;
ret = usb_stor_get_info(udev, data, blkdev);
- if (ret == 1)
- ret = blk_prepare_device(dev);
- if (!ret) {
+ if (ret == 1) {
usb_max_devs++;
debug("%s: Found device %p\n", __func__, udev);
} else {
diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c
index 9e0c823..c85b392 100644
--- a/drivers/block/blk-uclass.c
+++ b/drivers/block/blk-uclass.c
@@ -621,8 +621,20 @@ int blk_unbind_all(int if_type)
return 0;
}
+static int blk_post_probe(struct udevice *dev)
+{
+#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
+ struct blk_desc *desc = dev_get_uclass_platdata(dev);
+
+ part_init(desc);
+#endif
+
+ return 0;
+}
+
UCLASS_DRIVER(blk) = {
.id = UCLASS_BLK,
.name = "blk",
+ .post_probe = blk_post_probe,
.per_device_platdata_auto_alloc_size = sizeof(struct blk_desc),
};
diff --git a/drivers/block/ide.c b/drivers/block/ide.c
index 38adb6a..4b8a4ea 100644
--- a/drivers/block/ide.c
+++ b/drivers/block/ide.c
@@ -1169,8 +1169,6 @@ static int ide_blk_probe(struct udevice *udev)
BLK_REV_SIZE);
desc->revision[BLK_REV_SIZE] = '\0';
- part_init(desc);
-
return 0;
}
diff --git a/drivers/block/sandbox.c b/drivers/block/sandbox.c
index 576d049..d3b1aaa 100644
--- a/drivers/block/sandbox.c
+++ b/drivers/block/sandbox.c
@@ -142,7 +142,7 @@ int host_dev_bind(int devnum, char *filename)
goto err_file;
}
- return blk_prepare_device(dev);
+ return 0;
err_file:
os_close(fd);
err:
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c
index 585951c..d6b9cdc 100644
--- a/drivers/mmc/mmc.c
+++ b/drivers/mmc/mmc.c
@@ -2444,9 +2444,6 @@ static int mmc_startup(struct mmc *mmc)
bdesc->product[0] = 0;
bdesc->revision[0] = 0;
#endif
-#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
- part_init(bdesc);
-#endif
return 0;
}
diff --git a/drivers/nvme/nvme.c b/drivers/nvme/nvme.c
index eb6fded..1ee0a0a 100644
--- a/drivers/nvme/nvme.c
+++ b/drivers/nvme/nvme.c
@@ -664,7 +664,6 @@ static int nvme_blk_probe(struct udevice *udev)
sprintf(desc->vendor, "0x%.4x", pplat->vendor);
memcpy(desc->product, ndev->serial, sizeof(ndev->serial));
memcpy(desc->revision, ndev->firmware_rev, sizeof(ndev->firmware_rev));
- part_init(desc);
return 0;
}
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index bc6ac8c..df47e2f 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -592,7 +592,6 @@ static int do_scsi_scan_one(struct udevice *dev, int id, int lun, bool verbose)
memcpy(&bdesc->vendor, &bd.vendor, sizeof(bd.vendor));
memcpy(&bdesc->product, &bd.product, sizeof(bd.product));
memcpy(&bdesc->revision, &bd.revision, sizeof(bd.revision));
- part_init(bdesc);
if (verbose) {
printf(" Device %d: ", 0);
diff --git a/lib/efi_driver/efi_block_device.c b/lib/efi_driver/efi_block_device.c
index 7b71b4d..3f147cf 100644
--- a/lib/efi_driver/efi_block_device.c
+++ b/lib/efi_driver/efi_block_device.c
@@ -173,8 +173,6 @@ static int efi_bl_bind(efi_handle_t handle, void *interface)
return ret;
EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
- ret = blk_prepare_device(bdev);
-
/* Create handles for the partions of the block device */
disks = efi_bl_bind_partitions(handle, bdev);
EFI_PRINT("Found %d partitions\n", disks);
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 10/27] blk: Drop blk_prepare_device()
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (8 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 09/27] blk: Call part_init() in the post_probe() method Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 11/27] blk: Make blk_next_free_devnum() public Bin Meng
` (17 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
With the post_probe() changes, this API is no longer needed.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/block/blk-uclass.c | 9 ---------
include/blk.h | 10 ----------
2 files changed, 19 deletions(-)
diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c
index c85b392..acd2c69 100644
--- a/drivers/block/blk-uclass.c
+++ b/drivers/block/blk-uclass.c
@@ -448,15 +448,6 @@ unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start,
return ops->erase(dev, start, blkcnt);
}
-int blk_prepare_device(struct udevice *dev)
-{
- struct blk_desc *desc = dev_get_uclass_platdata(dev);
-
- part_init(desc);
-
- return 0;
-}
-
int blk_get_from_parent(struct udevice *parent, struct udevice **devp)
{
struct udevice *dev;
diff --git a/include/blk.h b/include/blk.h
index 86f6d50..32104ff 100644
--- a/include/blk.h
+++ b/include/blk.h
@@ -357,16 +357,6 @@ int blk_create_devicef(struct udevice *parent, const char *drv_name,
lbaint_t lba, struct udevice **devp);
/**
- * blk_prepare_device() - Prepare a block device for use
- *
- * This reads partition information from the device if supported.
- *
- * @dev: Device to prepare
- * @return 0 if ok, -ve on error
- */
-int blk_prepare_device(struct udevice *dev);
-
-/**
* blk_unbind_all() - Unbind all device of the given interface type
*
* The devices are removed and then unbound.
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 11/27] blk: Make blk_next_free_devnum() public
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (9 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 10/27] blk: Drop blk_prepare_device() Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 12/27] blk: Introduce IF_TYPE_VIRTIO Bin Meng
` (16 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
blk_next_free_devnum() can be helpful in some cases. Make it
a public API.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/block/blk-uclass.c | 2 +-
include/blk.h | 11 +++++++++++
2 files changed, 12 insertions(+), 1 deletion(-)
diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c
index acd2c69..c14da1f 100644
--- a/drivers/block/blk-uclass.c
+++ b/drivers/block/blk-uclass.c
@@ -494,7 +494,7 @@ int blk_find_max_devnum(enum if_type if_type)
return max_devnum;
}
-static int blk_next_free_devnum(enum if_type if_type)
+int blk_next_free_devnum(enum if_type if_type)
{
int ret;
diff --git a/include/blk.h b/include/blk.h
index 32104ff..9787a20 100644
--- a/include/blk.h
+++ b/include/blk.h
@@ -379,6 +379,17 @@ int blk_unbind_all(int if_type);
int blk_find_max_devnum(enum if_type if_type);
/**
+ * blk_next_free_devnum() - get the next device number for an interface type
+ *
+ * Finds the next number that is safe to use for a newly allocated device for
+ * an interface type @if_type.
+ *
+ * @if_type: Interface type to scan
+ * @return next device number safe to use, or -ve on error
+ */
+int blk_next_free_devnum(enum if_type if_type);
+
+/**
* blk_select_hwpart() - select a hardware partition
*
* Select a hardware partition if the device supports it (typically MMC does)
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 12/27] blk: Introduce IF_TYPE_VIRTIO
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (10 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 11/27] blk: Make blk_next_free_devnum() public Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 13/27] virtio: Add block driver support Bin Meng
` (15 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
This adds a new block interface type for VirtIO block devices.
Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
disk/part.c | 6 ++++++
drivers/block/blk-uclass.c | 2 ++
include/blk.h | 1 +
3 files changed, 9 insertions(+)
diff --git a/disk/part.c b/disk/part.c
index 9e457a6..f30f9e9 100644
--- a/disk/part.c
+++ b/disk/part.c
@@ -150,6 +150,9 @@ void dev_print (struct blk_desc *dev_desc)
dev_desc->revision,
dev_desc->product);
break;
+ case IF_TYPE_VIRTIO:
+ printf("%s VirtIO Block Device\n", dev_desc->vendor);
+ break;
case IF_TYPE_DOC:
puts("device type DOC\n");
return;
@@ -281,6 +284,9 @@ static void print_part_header(const char *type, struct blk_desc *dev_desc)
case IF_TYPE_NVME:
puts ("NVMe");
break;
+ case IF_TYPE_VIRTIO:
+ puts("VirtIO");
+ break;
default:
puts ("UNKNOWN");
break;
diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c
index c14da1f..dda1f58 100644
--- a/drivers/block/blk-uclass.c
+++ b/drivers/block/blk-uclass.c
@@ -23,6 +23,7 @@ static const char *if_typename_str[IF_TYPE_COUNT] = {
[IF_TYPE_HOST] = "host",
[IF_TYPE_NVME] = "nvme",
[IF_TYPE_EFI] = "efi",
+ [IF_TYPE_VIRTIO] = "virtio",
};
static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
@@ -37,6 +38,7 @@ static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
[IF_TYPE_HOST] = UCLASS_ROOT,
[IF_TYPE_NVME] = UCLASS_NVME,
[IF_TYPE_EFI] = UCLASS_EFI,
+ [IF_TYPE_VIRTIO] = UCLASS_VIRTIO,
};
static enum if_type if_typename_to_iftype(const char *if_typename)
diff --git a/include/blk.h b/include/blk.h
index 9787a20..170ed19 100644
--- a/include/blk.h
+++ b/include/blk.h
@@ -33,6 +33,7 @@ enum if_type {
IF_TYPE_HOST,
IF_TYPE_NVME,
IF_TYPE_EFI,
+ IF_TYPE_VIRTIO,
IF_TYPE_COUNT, /* Number of interface types */
};
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 13/27] virtio: Add block driver support
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (11 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 12/27] blk: Introduce IF_TYPE_VIRTIO Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 14/27] virtio: cmd: Add virtio command for virtio block devices Bin Meng
` (14 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
This adds virtio block device driver support.
Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/virtio/Kconfig | 7 +++
drivers/virtio/Makefile | 1 +
drivers/virtio/virtio_blk.c | 127 +++++++++++++++++++++++++++++++++++++++++++
drivers/virtio/virtio_blk.h | 129 ++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 264 insertions(+)
create mode 100644 drivers/virtio/virtio_blk.c
create mode 100644 drivers/virtio/virtio_blk.h
diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
index ceea03a..01bd116 100644
--- a/drivers/virtio/Kconfig
+++ b/drivers/virtio/Kconfig
@@ -25,4 +25,11 @@ config VIRTIO_NET
This is the virtual net driver for virtio. It can be used with
QEMU based targets.
+config VIRTIO_BLK
+ bool "virtio block driver"
+ depends on VIRTIO
+ help
+ This is the virtual block driver for virtio. It can be used with
+ QEMU based targets.
+
endmenu
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
index b7764f1..5fe7428 100644
--- a/drivers/virtio/Makefile
+++ b/drivers/virtio/Makefile
@@ -6,3 +6,4 @@
obj-y += virtio-uclass.o virtio_ring.o
obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o
obj-$(CONFIG_VIRTIO_NET) += virtio_net.o
+obj-$(CONFIG_VIRTIO_BLK) += virtio_blk.o
diff --git a/drivers/virtio/virtio_blk.c b/drivers/virtio/virtio_blk.c
new file mode 100644
index 0000000..9601abb
--- /dev/null
+++ b/drivers/virtio/virtio_blk.c
@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ */
+
+#include <common.h>
+#include <blk.h>
+#include <dm.h>
+#include <virtio.h>
+#include <virtio_ring.h>
+#include "virtio_blk.h"
+
+struct virtio_blk_priv {
+ struct virtqueue *vq;
+};
+
+static ulong virtio_blk_do_req(struct udevice *dev, u64 sector,
+ lbaint_t blkcnt, void *buffer, u32 type)
+{
+ struct virtio_blk_priv *priv = dev_get_priv(dev);
+ unsigned int num_out = 0, num_in = 0;
+ struct virtio_sg *sgs[3];
+ u8 status;
+ int ret;
+
+ struct virtio_blk_outhdr out_hdr = {
+ .type = cpu_to_virtio32(dev, type),
+ .sector = cpu_to_virtio64(dev, sector),
+ };
+ struct virtio_sg hdr_sg = { &out_hdr, sizeof(out_hdr) };
+ struct virtio_sg data_sg = { buffer, blkcnt * 512 };
+ struct virtio_sg status_sg = { &status, sizeof(status) };
+
+ sgs[num_out++] = &hdr_sg;
+
+ if (type & VIRTIO_BLK_T_OUT)
+ sgs[num_out++] = &data_sg;
+ else
+ sgs[num_out + num_in++] = &data_sg;
+
+ sgs[num_out + num_in++] = &status_sg;
+
+ ret = virtqueue_add(priv->vq, sgs, num_out, num_in);
+ if (ret)
+ return ret;
+
+ virtqueue_kick(priv->vq);
+
+ while (!virtqueue_get_buf(priv->vq, NULL))
+ ;
+
+ return status == VIRTIO_BLK_S_OK ? blkcnt : -EIO;
+}
+
+static ulong virtio_blk_read(struct udevice *dev, lbaint_t start,
+ lbaint_t blkcnt, void *buffer)
+{
+ return virtio_blk_do_req(dev, start, blkcnt, buffer,
+ VIRTIO_BLK_T_IN);
+}
+
+static ulong virtio_blk_write(struct udevice *dev, lbaint_t start,
+ lbaint_t blkcnt, const void *buffer)
+{
+ return virtio_blk_do_req(dev, start, blkcnt, (void *)buffer,
+ VIRTIO_BLK_T_OUT);
+}
+
+static int virtio_blk_bind(struct udevice *dev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(dev->parent);
+ struct blk_desc *desc = dev_get_uclass_platdata(dev);
+ int devnum;
+
+ desc->if_type = IF_TYPE_VIRTIO;
+ /*
+ * Initialize the devnum to -ENODEV. This is to make sure that
+ * blk_next_free_devnum() works as expected, since the default
+ * value 0 is a valid devnum.
+ */
+ desc->devnum = -ENODEV;
+ devnum = blk_next_free_devnum(IF_TYPE_VIRTIO);
+ if (devnum < 0)
+ return devnum;
+ desc->devnum = devnum;
+ desc->part_type = PART_TYPE_UNKNOWN;
+ sprintf(desc->vendor, "%s", (char *)&uc_priv->vendor);
+ desc->bdev = dev;
+
+ /* Indicate what driver features we support */
+ virtio_driver_features_init(uc_priv, NULL, 0, NULL, 0);
+
+ return 0;
+}
+
+static int virtio_blk_probe(struct udevice *dev)
+{
+ struct virtio_blk_priv *priv = dev_get_priv(dev);
+ struct blk_desc *desc = dev_get_uclass_platdata(dev);
+ u64 cap;
+ int ret;
+
+ ret = virtio_find_vqs(dev, 1, &priv->vq);
+ if (ret)
+ return ret;
+
+ desc->blksz = 512;
+ virtio_cread(dev, struct virtio_blk_config, capacity, &cap);
+ desc->lba = cap;
+
+ return 0;
+}
+
+static const struct blk_ops virtio_blk_ops = {
+ .read = virtio_blk_read,
+ .write = virtio_blk_write,
+};
+
+U_BOOT_DRIVER(virtio_blk) = {
+ .name = VIRTIO_BLK_DRV_NAME,
+ .id = UCLASS_BLK,
+ .ops = &virtio_blk_ops,
+ .bind = virtio_blk_bind,
+ .probe = virtio_blk_probe,
+ .priv_auto_alloc_size = sizeof(struct virtio_blk_priv),
+};
diff --git a/drivers/virtio/virtio_blk.h b/drivers/virtio/virtio_blk.h
new file mode 100644
index 0000000..8d8e02f
--- /dev/null
+++ b/drivers/virtio/virtio_blk.h
@@ -0,0 +1,129 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * From Linux kernel include/uapi/linux/virtio_blk.h
+ */
+
+#ifndef _LINUX_VIRTIO_BLK_H
+#define _LINUX_VIRTIO_BLK_H
+
+/* Feature bits */
+#define VIRTIO_BLK_F_SIZE_MAX 1 /* Indicates maximum segment size */
+#define VIRTIO_BLK_F_SEG_MAX 2 /* Indicates maximum # of segments */
+#define VIRTIO_BLK_F_GEOMETRY 4 /* Legacy geometry available */
+#define VIRTIO_BLK_F_RO 5 /* Disk is read-only */
+#define VIRTIO_BLK_F_BLK_SIZE 6 /* Block size of disk is available */
+#define VIRTIO_BLK_F_TOPOLOGY 10 /* Topology information is available */
+#define VIRTIO_BLK_F_MQ 12 /* Support more than one vq */
+
+/* Legacy feature bits */
+#ifndef VIRTIO_BLK_NO_LEGACY
+#define VIRTIO_BLK_F_BARRIER 0 /* Does host support barriers? */
+#define VIRTIO_BLK_F_SCSI 7 /* Supports scsi command passthru */
+#define VIRTIO_BLK_F_FLUSH 9 /* Flush command supported */
+#define VIRTIO_BLK_F_CONFIG_WCE 11 /* Writeback mode available in config */
+#ifndef __KERNEL__
+/* Old (deprecated) name for VIRTIO_BLK_F_FLUSH */
+#define VIRTIO_BLK_F_WCE VIRTIO_BLK_F_FLUSH
+#endif
+#endif /* !VIRTIO_BLK_NO_LEGACY */
+
+#define VIRTIO_BLK_ID_BYTES 20 /* ID string length */
+
+struct __packed virtio_blk_config {
+ /* The capacity (in 512-byte sectors) */
+ __u64 capacity;
+ /* The maximum segment size (if VIRTIO_BLK_F_SIZE_MAX) */
+ __u32 size_max;
+ /* The maximum number of segments (if VIRTIO_BLK_F_SEG_MAX) */
+ __u32 seg_max;
+ /* geometry of the device (if VIRTIO_BLK_F_GEOMETRY) */
+ struct virtio_blk_geometry {
+ __u16 cylinders;
+ __u8 heads;
+ __u8 sectors;
+ } geometry;
+
+ /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */
+ __u32 blk_size;
+
+ /* the next 4 entries are guarded by VIRTIO_BLK_F_TOPOLOGY */
+ /* exponent for physical block per logical block */
+ __u8 physical_block_exp;
+ /* alignment offset in logical blocks */
+ __u8 alignment_offset;
+ /* minimum I/O size without performance penalty in logical blocks */
+ __u16 min_io_size;
+ /* optimal sustained I/O size in logical blocks */
+ __u32 opt_io_size;
+
+ /* writeback mode (if VIRTIO_BLK_F_CONFIG_WCE) */
+ __u8 wce;
+ __u8 unused;
+
+ /* number of vqs, only available when VIRTIO_BLK_F_MQ is set */
+ __u16 num_queues;
+};
+
+/*
+ * Command types
+ *
+ * Usage is a bit tricky as some bits are used as flags and some are not.
+ *
+ * Rules:
+ * VIRTIO_BLK_T_OUT may be combined with VIRTIO_BLK_T_SCSI_CMD or
+ * VIRTIO_BLK_T_BARRIER. VIRTIO_BLK_T_FLUSH is a command of its own
+ * and may not be combined with any of the other flags.
+ */
+
+/* These two define direction */
+#define VIRTIO_BLK_T_IN 0
+#define VIRTIO_BLK_T_OUT 1
+
+#ifndef VIRTIO_BLK_NO_LEGACY
+/* This bit says it's a scsi command, not an actual read or write */
+#define VIRTIO_BLK_T_SCSI_CMD 2
+#endif /* VIRTIO_BLK_NO_LEGACY */
+
+/* Cache flush command */
+#define VIRTIO_BLK_T_FLUSH 4
+
+/* Get device ID command */
+#define VIRTIO_BLK_T_GET_ID 8
+
+#ifndef VIRTIO_BLK_NO_LEGACY
+/* Barrier before this op */
+#define VIRTIO_BLK_T_BARRIER 0x80000000
+#endif /* !VIRTIO_BLK_NO_LEGACY */
+
+/*
+ * This comes first in the read scatter-gather list.
+ * For legacy virtio, if VIRTIO_F_ANY_LAYOUT is not negotiated,
+ * this is the first element of the read scatter-gather list.
+ */
+struct virtio_blk_outhdr {
+ /* VIRTIO_BLK_T* */
+ __virtio32 type;
+ /* io priority */
+ __virtio32 ioprio;
+ /* Sector (ie. 512 byte offset) */
+ __virtio64 sector;
+};
+
+#ifndef VIRTIO_BLK_NO_LEGACY
+struct virtio_scsi_inhdr {
+ __virtio32 errors;
+ __virtio32 data_len;
+ __virtio32 sense_len;
+ __virtio32 residual;
+};
+#endif /* !VIRTIO_BLK_NO_LEGACY */
+
+/* And this is the final byte of the write scatter-gather list */
+#define VIRTIO_BLK_S_OK 0
+#define VIRTIO_BLK_S_IOERR 1
+#define VIRTIO_BLK_S_UNSUPP 2
+
+#endif /* _LINUX_VIRTIO_BLK_H */
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 14/27] virtio: cmd: Add virtio command for virtio block devices
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (12 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 13/27] virtio: Add block driver support Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 15/27] arm: qemu: Add a Kconfig in the board directory Bin Meng
` (13 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
Add 'virtio' command in U-Boot command line.
Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
cmd/Kconfig | 7 +++++++
cmd/Makefile | 1 +
cmd/virtio.c | 37 +++++++++++++++++++++++++++++++++++++
3 files changed, 45 insertions(+)
create mode 100644 cmd/virtio.c
diff --git a/cmd/Kconfig b/cmd/Kconfig
index 13d4c99..0bde692 100644
--- a/cmd/Kconfig
+++ b/cmd/Kconfig
@@ -1044,6 +1044,13 @@ config CMD_USB_MASS_STORAGE
help
USB mass storage support
+config CMD_VIRTIO
+ bool "virtio"
+ depends on VIRTIO_BLK
+ default y if VIRTIO_BLK
+ help
+ VirtIO block device support
+
config CMD_AXI
bool "axi"
depends on AXI
diff --git a/cmd/Makefile b/cmd/Makefile
index a61fab6..5946e6b 100644
--- a/cmd/Makefile
+++ b/cmd/Makefile
@@ -133,6 +133,7 @@ obj-$(CONFIG_CMD_UBI) += ubi.o
obj-$(CONFIG_CMD_UBIFS) += ubifs.o
obj-$(CONFIG_CMD_UNIVERSE) += universe.o
obj-$(CONFIG_CMD_UNZIP) += unzip.o
+obj-$(CONFIG_CMD_VIRTIO) += virtio.o
obj-$(CONFIG_CMD_LZMADEC) += lzmadec.o
obj-$(CONFIG_CMD_USB) += usb.o disk.o
diff --git a/cmd/virtio.c b/cmd/virtio.c
new file mode 100644
index 0000000..7f83693
--- /dev/null
+++ b/cmd/virtio.c
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ */
+
+#include <common.h>
+#include <command.h>
+#include <dm.h>
+#include <virtio.h>
+
+static int virtio_curr_dev;
+
+static int do_virtio(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+ if (argc == 2 && !strcmp(argv[1], "scan")) {
+ /* make sure all virtio devices are enumerated */
+ virtio_init();
+
+ return CMD_RET_SUCCESS;
+ }
+
+ return blk_common_cmd(argc, argv, IF_TYPE_VIRTIO, &virtio_curr_dev);
+}
+
+U_BOOT_CMD(
+ virtio, 8, 1, do_virtio,
+ "virtio block devices sub-system",
+ "scan - initialize virtio bus\n"
+ "virtio info - show all available virtio block devices\n"
+ "virtio device [dev] - show or set current virtio block device\n"
+ "virtio part [dev] - print partition table of one or all virtio block devices\n"
+ "virtio read addr blk# cnt - read `cnt' blocks starting at block\n"
+ " `blk#' to memory address `addr'\n"
+ "virtio write addr blk# cnt - write `cnt' blocks starting at block\n"
+ " `blk#' from memory address `addr'"
+);
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 15/27] arm: qemu: Add a Kconfig in the board directory
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (13 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 14/27] virtio: cmd: Add virtio command for virtio block devices Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot Bin Meng
` (12 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
This adds a Kconfig file in the board directory, so that some
board-specific options can be specified there.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
arch/arm/Kconfig | 1 +
board/emulation/qemu-arm/Kconfig | 9 +++++++++
configs/qemu_arm64_defconfig | 1 -
configs/qemu_arm_defconfig | 1 -
4 files changed, 10 insertions(+), 2 deletions(-)
create mode 100644 board/emulation/qemu-arm/Kconfig
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 0f8dd32..f0917cc 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -1472,6 +1472,7 @@ source "board/broadcom/bcmns2/Kconfig"
source "board/cavium/thunderx/Kconfig"
source "board/cirrus/edb93xx/Kconfig"
source "board/eets/pdu001/Kconfig"
+source "board/emulation/qemu-arm/Kconfig"
source "board/freescale/ls2080a/Kconfig"
source "board/freescale/ls2080aqds/Kconfig"
source "board/freescale/ls2080ardb/Kconfig"
diff --git a/board/emulation/qemu-arm/Kconfig b/board/emulation/qemu-arm/Kconfig
new file mode 100644
index 0000000..d1c08c2
--- /dev/null
+++ b/board/emulation/qemu-arm/Kconfig
@@ -0,0 +1,9 @@
+if TARGET_QEMU_ARM_32BIT || TARGET_QEMU_ARM_64BIT
+
+config SYS_TEXT_BASE
+ default 0x00000000
+
+config BOARD_SPECIFIC_OPTIONS # dummy
+ def_bool y
+
+endif
diff --git a/configs/qemu_arm64_defconfig b/configs/qemu_arm64_defconfig
index 2df35a8..131ca19 100644
--- a/configs/qemu_arm64_defconfig
+++ b/configs/qemu_arm64_defconfig
@@ -1,7 +1,6 @@
CONFIG_ARM=y
CONFIG_ARM_SMCCC=y
CONFIG_ARCH_QEMU=y
-CONFIG_SYS_TEXT_BASE=0x00000000
CONFIG_TARGET_QEMU_ARM_64BIT=y
CONFIG_AHCI=y
CONFIG_DISTRO_DEFAULTS=y
diff --git a/configs/qemu_arm_defconfig b/configs/qemu_arm_defconfig
index 2865599..3c139fe 100644
--- a/configs/qemu_arm_defconfig
+++ b/configs/qemu_arm_defconfig
@@ -1,7 +1,6 @@
CONFIG_ARM=y
CONFIG_ARM_SMCCC=y
CONFIG_ARCH_QEMU=y
-CONFIG_SYS_TEXT_BASE=0x00000000
CONFIG_TARGET_QEMU_ARM_32BIT=y
CONFIG_AHCI=y
CONFIG_DISTRO_DEFAULTS=y
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (14 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 15/27] arm: qemu: Add a Kconfig in the board directory Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-27 22:13 ` Tuomas Tynkkynen
2018-09-23 13:42 ` [U-Boot] [PATCH 17/27] riscv: " Bin Meng
` (11 subsequent siblings)
27 siblings, 2 replies; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
Currently devices on the virtio bus is not automatically enumerated,
which means peripherals on the virtio bus are not discovered by their
drivers. This uses board_init() to do the virtio enumeration.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
board/emulation/qemu-arm/Kconfig | 3 +++
board/emulation/qemu-arm/qemu-arm.c | 7 +++++++
2 files changed, 10 insertions(+)
diff --git a/board/emulation/qemu-arm/Kconfig b/board/emulation/qemu-arm/Kconfig
index d1c08c2..16b80fe 100644
--- a/board/emulation/qemu-arm/Kconfig
+++ b/board/emulation/qemu-arm/Kconfig
@@ -5,5 +5,8 @@ config SYS_TEXT_BASE
config BOARD_SPECIFIC_OPTIONS # dummy
def_bool y
+ imply VIRTIO_MMIO
+ imply VIRTIO_NET
+ imply VIRTIO_BLK
endif
diff --git a/board/emulation/qemu-arm/qemu-arm.c b/board/emulation/qemu-arm/qemu-arm.c
index 812c906..428498e 100644
--- a/board/emulation/qemu-arm/qemu-arm.c
+++ b/board/emulation/qemu-arm/qemu-arm.c
@@ -4,6 +4,7 @@
*/
#include <common.h>
#include <fdtdec.h>
+#include <virtio.h>
#ifdef CONFIG_ARM64
#include <asm/armv8/mmu.h>
@@ -58,6 +59,12 @@ struct mm_region *mem_map = qemu_arm64_mem_map;
int board_init(void)
{
+ /*
+ * Make sure virtio bus is enumerated so that peripherals
+ * on the virtio bus can be discovered by their drivers
+ */
+ virtio_init();
+
return 0;
}
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 17/27] riscv: qemu: Enumerate virtio bus during early boot
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (15 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 18/27] riscv: qemu: Include some useful commands Bin Meng
` (10 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
Currently devices on the virtio bus is not automatically enumerated,
which means peripherals on the virtio bus are not discovered by their
drivers. This uses board_init() to do the virtio enumeration.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
board/emulation/qemu-riscv/Kconfig | 3 +++
board/emulation/qemu-riscv/qemu-riscv.c | 7 +++++++
2 files changed, 10 insertions(+)
diff --git a/board/emulation/qemu-riscv/Kconfig b/board/emulation/qemu-riscv/Kconfig
index af23363..5ae56da 100644
--- a/board/emulation/qemu-riscv/Kconfig
+++ b/board/emulation/qemu-riscv/Kconfig
@@ -18,5 +18,8 @@ config SYS_TEXT_BASE
config BOARD_SPECIFIC_OPTIONS # dummy
def_bool y
imply SYS_NS16550
+ imply VIRTIO_MMIO
+ imply VIRTIO_NET
+ imply VIRTIO_BLK
endif
diff --git a/board/emulation/qemu-riscv/qemu-riscv.c b/board/emulation/qemu-riscv/qemu-riscv.c
index 041e716..5ab0a62 100644
--- a/board/emulation/qemu-riscv/qemu-riscv.c
+++ b/board/emulation/qemu-riscv/qemu-riscv.c
@@ -5,11 +5,18 @@
#include <common.h>
#include <fdtdec.h>
+#include <virtio.h>
#define MROM_FDT_ADDR 0x1020
int board_init(void)
{
+ /*
+ * Make sure virtio bus is enumerated so that peripherals
+ * on the virtio bus can be discovered by their drivers
+ */
+ virtio_init();
+
return 0;
}
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 18/27] riscv: qemu: Include some useful commands
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (16 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 17/27] riscv: " Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-27 22:14 ` Tuomas Tynkkynen
2018-09-23 13:42 ` [U-Boot] [PATCH 19/27] kconfig: Introduce HAVE_ARCH_IOMAP Bin Meng
` (9 subsequent siblings)
27 siblings, 2 replies; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
With the virtio net and blk drivers, we can do more stuff with some
useful commands. Imply those in the board Kconfig.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
board/emulation/qemu-riscv/Kconfig | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/board/emulation/qemu-riscv/Kconfig b/board/emulation/qemu-riscv/Kconfig
index 5ae56da..37a80db 100644
--- a/board/emulation/qemu-riscv/Kconfig
+++ b/board/emulation/qemu-riscv/Kconfig
@@ -21,5 +21,13 @@ config BOARD_SPECIFIC_OPTIONS # dummy
imply VIRTIO_MMIO
imply VIRTIO_NET
imply VIRTIO_BLK
+ imply CMD_PING
+ imply CMD_FS_GENERIC
+ imply DOS_PARTITION
+ imply EFI_PARTITION
+ imply ISO_PARTITION
+ imply CMD_EXT2
+ imply CMD_EXT4
+ imply CMD_FAT
endif
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 19/27] kconfig: Introduce HAVE_ARCH_IOMAP
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (17 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 18/27] riscv: qemu: Include some useful commands Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 20/27] x86: Implement arch-specific io accessor routines Bin Meng
` (8 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
Introduce a new Kconfig option for architecture codes to control
whether it provides io{read,write}{8,16,32} I/O accessor functions.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
include/linux/io.h | 4 ++++
lib/Kconfig | 6 ++++++
2 files changed, 10 insertions(+)
diff --git a/include/linux/io.h b/include/linux/io.h
index d1b3efe..9badab4 100644
--- a/include/linux/io.h
+++ b/include/linux/io.h
@@ -7,6 +7,7 @@
#include <linux/types.h>
#include <asm/io.h>
+#ifndef CONFIG_HAVE_ARCH_IOMAP
static inline u8 ioread8(const volatile void __iomem *addr)
{
return readb(addr);
@@ -21,6 +22,7 @@ static inline u32 ioread32(const volatile void __iomem *addr)
{
return readl(addr);
}
+#endif /* !CONFIG_HAVE_ARCH_IOMAP */
#ifdef CONFIG_64BIT
static inline u64 ioread64(const volatile void __iomem *addr)
@@ -29,6 +31,7 @@ static inline u64 ioread64(const volatile void __iomem *addr)
}
#endif /* CONFIG_64BIT */
+#ifndef CONFIG_HAVE_ARCH_IOMAP
static inline void iowrite8(u8 value, volatile void __iomem *addr)
{
writeb(value, addr);
@@ -43,6 +46,7 @@ static inline void iowrite32(u32 value, volatile void __iomem *addr)
{
writel(value, addr);
}
+#endif /* !CONFIG_HAVE_ARCH_IOMAP */
#ifdef CONFIG_64BIT
static inline void iowrite64(u64 value, volatile void __iomem *addr)
diff --git a/lib/Kconfig b/lib/Kconfig
index 622f3c2..64c3825 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -21,6 +21,12 @@ config DYNAMIC_CRC_TABLE
Enable this option to calculate entries for CRC tables at runtime.
This can be helpful when reducing the size of the build image
+config HAVE_ARCH_IOMAP
+ bool
+ help
+ Enable this option if architecture provides io{read,write}{8,16,32}
+ I/O accessor functions.
+
config HAVE_PRIVATE_LIBGCC
bool
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 20/27] x86: Implement arch-specific io accessor routines
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (18 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 19/27] kconfig: Introduce HAVE_ARCH_IOMAP Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 21/27] virtio: Add virtio over pci transport driver Bin Meng
` (7 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
At present the generic io{read,write}{8,16,32} routines only support
MMIO access. With architecture like x86 that has a separate IO space,
these routines cannot be used to access I/O ports.
Implement x86-specific version to support both PIO and MMIO access,
so that drivers for multiple architectures can use these accessors
without the need to know whether it's MMIO or PIO.
These are ported from Linux kernel lib/iomap.c, with slight changes.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
arch/Kconfig | 1 +
arch/x86/include/asm/io.h | 66 +++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 67 insertions(+)
diff --git a/arch/Kconfig b/arch/Kconfig
index ce183fa..178eb94 100644
--- a/arch/Kconfig
+++ b/arch/Kconfig
@@ -114,6 +114,7 @@ config X86
select CREATE_ARCH_SYMLINK
select DM
select DM_PCI
+ select HAVE_ARCH_IOMAP
select HAVE_PRIVATE_LIBGCC
select OF_CONTROL
select PCI
diff --git a/arch/x86/include/asm/io.h b/arch/x86/include/asm/io.h
index c05c6bf..81def0a 100644
--- a/arch/x86/include/asm/io.h
+++ b/arch/x86/include/asm/io.h
@@ -241,6 +241,72 @@ static inline void sync(void)
#define __iormb() dmb()
#define __iowmb() dmb()
+/*
+ * Read/write from/to an (offsettable) iomem cookie. It might be a PIO
+ * access or a MMIO access, these functions don't care. The info is
+ * encoded in the hardware mapping set up by the mapping functions
+ * (or the cookie itself, depending on implementation and hw).
+ *
+ * The generic routines don't assume any hardware mappings, and just
+ * encode the PIO/MMIO as part of the cookie. They coldly assume that
+ * the MMIO IO mappings are not in the low address range.
+ *
+ * Architectures for which this is not true can't use this generic
+ * implementation and should do their own copy.
+ */
+
+/*
+ * We assume that all the low physical PIO addresses (0-0xffff) always
+ * PIO. That means we can do some sanity checks on the low bits, and
+ * don't need to just take things for granted.
+ */
+#define PIO_RESERVED 0x10000UL
+
+/*
+ * Ugly macros are a way of life.
+ */
+#define IO_COND(addr, is_pio, is_mmio) do { \
+ unsigned long port = (unsigned long __force)addr; \
+ if (port >= PIO_RESERVED) { \
+ is_mmio; \
+ } else { \
+ is_pio; \
+ } \
+} while (0)
+
+static inline u8 ioread8(const volatile void __iomem *addr)
+{
+ IO_COND(addr, return inb(port), return readb(addr));
+ return 0xff;
+}
+
+static inline u16 ioread16(const volatile void __iomem *addr)
+{
+ IO_COND(addr, return inw(port), return readw(addr));
+ return 0xffff;
+}
+
+static inline u32 ioread32(const volatile void __iomem *addr)
+{
+ IO_COND(addr, return inl(port), return readl(addr));
+ return 0xffffffff;
+}
+
+static inline void iowrite8(u8 value, volatile void __iomem *addr)
+{
+ IO_COND(addr, outb(value, port), writeb(value, addr));
+}
+
+static inline void iowrite16(u16 value, volatile void __iomem *addr)
+{
+ IO_COND(addr, outw(value, port), writew(value, addr));
+}
+
+static inline void iowrite32(u32 value, volatile void __iomem *addr)
+{
+ IO_COND(addr, outl(value, port), writel(value, addr));
+}
+
#include <asm-generic/io.h>
#endif /* _ASM_IO_H */
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 21/27] virtio: Add virtio over pci transport driver
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (19 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 20/27] x86: Implement arch-specific io accessor routines Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 22/27] x86: qemu: Imply virtio PCI transport and device drivers Bin Meng
` (6 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
This adds a transport driver that implements UCLASS_VIRTIO for
virtio over pci, which is commonly used on x86.
It only supports the legacy interface of the pci transport, which
is the default device that QEMU emulates.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/virtio/Kconfig | 8 +
drivers/virtio/Makefile | 1 +
drivers/virtio/virtio_pci.c | 420 ++++++++++++++++++++++++++++++++++++++++++++
drivers/virtio/virtio_pci.h | 173 ++++++++++++++++++
4 files changed, 602 insertions(+)
create mode 100644 drivers/virtio/virtio_pci.c
create mode 100644 drivers/virtio/virtio_pci.h
diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
index 01bd116..6db2d73 100644
--- a/drivers/virtio/Kconfig
+++ b/drivers/virtio/Kconfig
@@ -18,6 +18,14 @@ config VIRTIO_MMIO
This driver provides support for memory mapped virtio
platform device driver.
+config VIRTIO_PCI
+ bool "PCI driver for virtio devices"
+ depends on DM_PCI
+ select VIRTIO
+ help
+ This driver provides support for virtio based paravirtual device
+ drivers over PCI.
+
config VIRTIO_NET
bool "virtio net driver"
depends on VIRTIO
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
index 5fe7428..5ee6183 100644
--- a/drivers/virtio/Makefile
+++ b/drivers/virtio/Makefile
@@ -5,5 +5,6 @@
obj-y += virtio-uclass.o virtio_ring.o
obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o
+obj-$(CONFIG_VIRTIO_PCI) += virtio_pci.o
obj-$(CONFIG_VIRTIO_NET) += virtio_net.o
obj-$(CONFIG_VIRTIO_BLK) += virtio_blk.o
diff --git a/drivers/virtio/virtio_pci.c b/drivers/virtio/virtio_pci.c
new file mode 100644
index 0000000..12ecd84
--- /dev/null
+++ b/drivers/virtio/virtio_pci.c
@@ -0,0 +1,420 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * VirtIO PCI bus transport driver
+ * Ported from Linux drivers/virtio/virtio_pci*.c
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <virtio.h>
+#include <virtio_ring.h>
+#include <dm/device.h>
+#include <linux/compat.h>
+#include <linux/io.h>
+#include "virtio_pci.h"
+
+#define VIRTIO_PCI_DRV_NAME "virtio-pci"
+
+/* PCI device ID in the range 0x1000 to 0x103f */
+#define VIRTIO_PCI_VENDOR_ID 0x1af4
+#define VIRTIO_PCI_DEVICE_ID00 0x1000
+#define VIRTIO_PCI_DEVICE_ID01 0x1001
+#define VIRTIO_PCI_DEVICE_ID02 0x1002
+#define VIRTIO_PCI_DEVICE_ID03 0x1003
+#define VIRTIO_PCI_DEVICE_ID04 0x1004
+#define VIRTIO_PCI_DEVICE_ID05 0x1005
+#define VIRTIO_PCI_DEVICE_ID06 0x1006
+#define VIRTIO_PCI_DEVICE_ID07 0x1007
+#define VIRTIO_PCI_DEVICE_ID08 0x1008
+#define VIRTIO_PCI_DEVICE_ID09 0x1009
+#define VIRTIO_PCI_DEVICE_ID0A 0x100a
+#define VIRTIO_PCI_DEVICE_ID0B 0x100b
+#define VIRTIO_PCI_DEVICE_ID0C 0x100c
+#define VIRTIO_PCI_DEVICE_ID0D 0x100d
+#define VIRTIO_PCI_DEVICE_ID0E 0x100e
+#define VIRTIO_PCI_DEVICE_ID0F 0x100f
+#define VIRTIO_PCI_DEVICE_ID10 0x1010
+#define VIRTIO_PCI_DEVICE_ID11 0x1011
+#define VIRTIO_PCI_DEVICE_ID12 0x1012
+#define VIRTIO_PCI_DEVICE_ID13 0x1013
+#define VIRTIO_PCI_DEVICE_ID14 0x1014
+#define VIRTIO_PCI_DEVICE_ID15 0x1015
+#define VIRTIO_PCI_DEVICE_ID16 0x1016
+#define VIRTIO_PCI_DEVICE_ID17 0x1017
+#define VIRTIO_PCI_DEVICE_ID18 0x1018
+#define VIRTIO_PCI_DEVICE_ID19 0x1019
+#define VIRTIO_PCI_DEVICE_ID1A 0x101a
+#define VIRTIO_PCI_DEVICE_ID1B 0x101b
+#define VIRTIO_PCI_DEVICE_ID1C 0x101c
+#define VIRTIO_PCI_DEVICE_ID1D 0x101d
+#define VIRTIO_PCI_DEVICE_ID1E 0x101e
+#define VIRTIO_PCI_DEVICE_ID1F 0x101f
+#define VIRTIO_PCI_DEVICE_ID20 0x1020
+#define VIRTIO_PCI_DEVICE_ID21 0x1021
+#define VIRTIO_PCI_DEVICE_ID22 0x1022
+#define VIRTIO_PCI_DEVICE_ID23 0x1023
+#define VIRTIO_PCI_DEVICE_ID24 0x1024
+#define VIRTIO_PCI_DEVICE_ID25 0x1025
+#define VIRTIO_PCI_DEVICE_ID26 0x1026
+#define VIRTIO_PCI_DEVICE_ID27 0x1027
+#define VIRTIO_PCI_DEVICE_ID28 0x1028
+#define VIRTIO_PCI_DEVICE_ID29 0x1029
+#define VIRTIO_PCI_DEVICE_ID2A 0x102a
+#define VIRTIO_PCI_DEVICE_ID2B 0x102b
+#define VIRTIO_PCI_DEVICE_ID2C 0x102c
+#define VIRTIO_PCI_DEVICE_ID2D 0x102d
+#define VIRTIO_PCI_DEVICE_ID2E 0x102e
+#define VIRTIO_PCI_DEVICE_ID2F 0x102f
+#define VIRTIO_PCI_DEVICE_ID30 0x1030
+#define VIRTIO_PCI_DEVICE_ID31 0x1031
+#define VIRTIO_PCI_DEVICE_ID32 0x1032
+#define VIRTIO_PCI_DEVICE_ID33 0x1033
+#define VIRTIO_PCI_DEVICE_ID34 0x1034
+#define VIRTIO_PCI_DEVICE_ID35 0x1035
+#define VIRTIO_PCI_DEVICE_ID36 0x1036
+#define VIRTIO_PCI_DEVICE_ID37 0x1037
+#define VIRTIO_PCI_DEVICE_ID38 0x1038
+#define VIRTIO_PCI_DEVICE_ID39 0x1039
+#define VIRTIO_PCI_DEVICE_ID3A 0x103a
+#define VIRTIO_PCI_DEVICE_ID3B 0x103b
+#define VIRTIO_PCI_DEVICE_ID3C 0x103c
+#define VIRTIO_PCI_DEVICE_ID3D 0x103d
+#define VIRTIO_PCI_DEVICE_ID3E 0x103e
+#define VIRTIO_PCI_DEVICE_ID3F 0x103f
+
+/**
+ * virtio pci transport driver private data
+ *
+ * @ioaddr: pci transport device register base
+ * @version: pci transport device version
+ */
+struct virtio_pci_priv {
+ void __iomem *ioaddr;
+};
+
+static int virtio_pci_get_config(struct udevice *udev, unsigned int offset,
+ void *buf, unsigned int len)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ void __iomem *ioaddr = priv->ioaddr + VIRTIO_PCI_CONFIG_OFF(false);
+ u8 *ptr = buf;
+ int i;
+
+ for (i = 0; i < len; i++)
+ ptr[i] = ioread8(ioaddr + i);
+
+ return 0;
+}
+
+static int virtio_pci_set_config(struct udevice *udev, unsigned int offset,
+ const void *buf, unsigned int len)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ void __iomem *ioaddr = priv->ioaddr + VIRTIO_PCI_CONFIG_OFF(false);
+ const u8 *ptr = buf;
+ int i;
+
+ for (i = 0; i < len; i++)
+ iowrite8(ptr[i], ioaddr + i);
+
+ return 0;
+}
+
+static int virtio_pci_get_status(struct udevice *udev, u8 *status)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ *status = ioread8(priv->ioaddr + VIRTIO_PCI_STATUS);
+
+ return 0;
+}
+
+static int virtio_pci_set_status(struct udevice *udev, u8 status)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ /* We should never be setting status to 0 */
+ WARN_ON(status == 0);
+
+ iowrite8(status, priv->ioaddr + VIRTIO_PCI_STATUS);
+
+ return 0;
+}
+
+static int virtio_pci_reset(struct udevice *udev)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ /* 0 status means a reset */
+ iowrite8(0, priv->ioaddr + VIRTIO_PCI_STATUS);
+
+ /*
+ * Flush out the status write, and flush in device writes,
+ * including MSi-X interrupts, if any.
+ */
+ ioread8(priv->ioaddr + VIRTIO_PCI_STATUS);
+
+ return 0;
+}
+
+static int virtio_pci_get_features(struct udevice *udev, u64 *features)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ /*
+ * When someone needs more than 32 feature bits, we'll need to
+ * steal a bit to indicate that the rest are somewhere else.
+ */
+ *features = ioread32(priv->ioaddr + VIRTIO_PCI_HOST_FEATURES);
+
+ return 0;
+}
+
+static int virtio_pci_set_features(struct udevice *udev)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+
+ /* Make sure we don't have any features > 32 bits! */
+ WARN_ON((u32)uc_priv->features != uc_priv->features);
+
+ /* We only support 32 feature bits */
+ iowrite32(uc_priv->features, priv->ioaddr + VIRTIO_PCI_GUEST_FEATURES);
+
+ return 0;
+}
+
+static struct virtqueue *virtio_pci_setup_vq(struct udevice *udev,
+ unsigned int index)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ struct virtqueue *vq;
+ unsigned int num;
+ int err;
+
+ /* Select the queue we're interested in */
+ iowrite16(index, priv->ioaddr + VIRTIO_PCI_QUEUE_SEL);
+
+ /* Check if queue is either not available or already active */
+ num = ioread16(priv->ioaddr + VIRTIO_PCI_QUEUE_NUM);
+ if (!num || ioread32(priv->ioaddr + VIRTIO_PCI_QUEUE_PFN)) {
+ err = -ENOENT;
+ goto error_available;
+ }
+
+ /* Create the vring */
+ vq = vring_create_virtqueue(index, num, VIRTIO_PCI_VRING_ALIGN, udev);
+ if (!vq) {
+ err = -ENOMEM;
+ goto error_available;
+ }
+
+ /* Activate the queue */
+ iowrite32(virtqueue_get_desc_addr(vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT,
+ priv->ioaddr + VIRTIO_PCI_QUEUE_PFN);
+
+ return vq;
+
+error_available:
+ return ERR_PTR(err);
+}
+
+static void virtio_pci_del_vq(struct virtqueue *vq)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(vq->vdev);
+ unsigned int index = vq->index;
+
+ iowrite16(index, priv->ioaddr + VIRTIO_PCI_QUEUE_SEL);
+
+ /* Select and deactivate the queue */
+ iowrite32(0, priv->ioaddr + VIRTIO_PCI_QUEUE_PFN);
+
+ vring_del_virtqueue(vq);
+}
+
+static int virtio_pci_del_vqs(struct udevice *udev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+ struct virtqueue *vq, *n;
+
+ list_for_each_entry_safe(vq, n, &uc_priv->vqs, list)
+ virtio_pci_del_vq(vq);
+
+ return 0;
+}
+
+static int virtio_pci_find_vqs(struct udevice *udev, unsigned int nvqs,
+ struct virtqueue *vqs[])
+{
+ int i;
+
+ for (i = 0; i < nvqs; ++i) {
+ vqs[i] = virtio_pci_setup_vq(udev, i);
+ if (IS_ERR(vqs[i])) {
+ virtio_pci_del_vqs(udev);
+ return PTR_ERR(vqs[i]);
+ }
+ }
+
+ return 0;
+}
+
+static int virtio_pci_notify(struct udevice *udev, struct virtqueue *vq)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ /*
+ * We write the queue's selector into the notification register
+ * to signal the other end
+ */
+ iowrite16(vq->index, priv->ioaddr + VIRTIO_PCI_QUEUE_NOTIFY);
+
+ return 0;
+}
+
+static int virtio_pci_bind(struct udevice *udev)
+{
+ static int num_devs;
+ char name[20];
+
+ /* Create a unique device name for PCI type devices */
+ sprintf(name, "%s#%u", VIRTIO_PCI_DRV_NAME, num_devs++);
+ device_set_name(udev, name);
+
+ return 0;
+}
+
+static int virtio_pci_probe(struct udevice *udev)
+{
+ struct pci_child_platdata *pplat = dev_get_parent_platdata(udev);
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ u16 subvendor, subdevice;
+ u8 revision;
+
+ /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */
+ if (pplat->device < 0x1000 || pplat->device > 0x103f)
+ return -ENODEV;
+
+ /* Transitional devices must have a PCI revision ID of 0 */
+ dm_pci_read_config8(udev, PCI_REVISION_ID, &revision);
+ if (revision != VIRTIO_PCI_ABI_VERSION) {
+ printf("(%s): virtio_pci expected ABI version %d, got %d\n",
+ udev->name, VIRTIO_PCI_ABI_VERSION, revision);
+ return -ENODEV;
+ }
+
+ /*
+ * Transitional devices must have the PCI subsystem device ID matching
+ * the virtio device ID
+ */
+ dm_pci_read_config16(udev, PCI_SUBSYSTEM_ID, &subdevice);
+ dm_pci_read_config16(udev, PCI_SUBSYSTEM_VENDOR_ID, &subvendor);
+ uc_priv->device = subdevice;
+ uc_priv->vendor = subvendor;
+
+ priv->ioaddr = dm_pci_map_bar(udev, PCI_BASE_ADDRESS_0, PCI_REGION_IO);
+ if (!priv->ioaddr)
+ return -ENXIO;
+ debug("(%s): virtio legacy device reg base %04lx\n",
+ udev->name, (ulong)priv->ioaddr);
+
+ debug("(%s): device (%d) vendor (%08x) version (%d)\n", udev->name,
+ uc_priv->device, uc_priv->vendor, revision);
+
+ return 0;
+}
+
+static const struct dm_virtio_ops virtio_pci_ops = {
+ .get_config = virtio_pci_get_config,
+ .set_config = virtio_pci_set_config,
+ .get_status = virtio_pci_get_status,
+ .set_status = virtio_pci_set_status,
+ .reset = virtio_pci_reset,
+ .get_features = virtio_pci_get_features,
+ .set_features = virtio_pci_set_features,
+ .find_vqs = virtio_pci_find_vqs,
+ .del_vqs = virtio_pci_del_vqs,
+ .notify = virtio_pci_notify,
+};
+
+U_BOOT_DRIVER(virtio_pci) = {
+ .name = VIRTIO_PCI_DRV_NAME,
+ .id = UCLASS_VIRTIO,
+ .ops = &virtio_pci_ops,
+ .bind = virtio_pci_bind,
+ .probe = virtio_pci_probe,
+ .priv_auto_alloc_size = sizeof(struct virtio_pci_priv),
+};
+
+static struct pci_device_id virtio_pci_supported[] = {
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID00) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID01) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID02) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID03) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID04) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID05) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID06) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID07) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID08) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID09) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0A) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0B) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0C) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0D) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0E) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0F) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID10) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID11) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID12) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID13) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID14) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID15) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID16) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID17) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID18) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID19) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1A) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1B) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1C) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1D) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1E) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1F) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID20) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID21) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID22) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID23) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID24) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID25) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID26) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID27) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID28) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID29) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2A) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2B) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2C) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2D) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2E) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2F) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID30) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID31) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID32) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID33) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID34) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID35) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID36) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID37) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID38) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID39) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3A) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3B) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3C) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3D) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3E) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3F) },
+ {},
+};
+
+U_BOOT_PCI_DEVICE(virtio_pci, virtio_pci_supported);
diff --git a/drivers/virtio/virtio_pci.h b/drivers/virtio/virtio_pci.h
new file mode 100644
index 0000000..cc753ed
--- /dev/null
+++ b/drivers/virtio/virtio_pci.h
@@ -0,0 +1,173 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * From Linux kernel include/uapi/linux/virtio_pci.h
+ */
+
+#ifndef _LINUX_VIRTIO_PCI_H
+#define _LINUX_VIRTIO_PCI_H
+
+#ifndef VIRTIO_PCI_NO_LEGACY
+
+/* A 32-bit r/o bitmask of the features supported by the host */
+#define VIRTIO_PCI_HOST_FEATURES 0
+
+/* A 32-bit r/w bitmask of features activated by the guest */
+#define VIRTIO_PCI_GUEST_FEATURES 4
+
+/* A 32-bit r/w PFN for the currently selected queue */
+#define VIRTIO_PCI_QUEUE_PFN 8
+
+/* A 16-bit r/o queue size for the currently selected queue */
+#define VIRTIO_PCI_QUEUE_NUM 12
+
+/* A 16-bit r/w queue selector */
+#define VIRTIO_PCI_QUEUE_SEL 14
+
+/* A 16-bit r/w queue notifier */
+#define VIRTIO_PCI_QUEUE_NOTIFY 16
+
+/* An 8-bit device status register */
+#define VIRTIO_PCI_STATUS 18
+
+/*
+ * An 8-bit r/o interrupt status register. Reading the value will return the
+ * current contents of the ISR and will also clear it. This is effectively
+ * a read-and-acknowledge.
+ */
+#define VIRTIO_PCI_ISR 19
+
+/* MSI-X registers: only enabled if MSI-X is enabled */
+
+/* A 16-bit vector for configuration changes */
+#define VIRTIO_MSI_CONFIG_VECTOR 20
+/* A 16-bit vector for selected queue notifications */
+#define VIRTIO_MSI_QUEUE_VECTOR 22
+
+/*
+ * The remaining space is defined by each driver as the per-driver
+ * configuration space
+ */
+#define VIRTIO_PCI_CONFIG_OFF(msix) ((msix) ? 24 : 20)
+
+/* Virtio ABI version, this must match exactly */
+#define VIRTIO_PCI_ABI_VERSION 0
+
+/*
+ * How many bits to shift physical queue address written to QUEUE_PFN.
+ * 12 is historical, and due to x86 page size.
+ */
+#define VIRTIO_PCI_QUEUE_ADDR_SHIFT 12
+
+/*
+ * The alignment to use between consumer and producer parts of vring.
+ * x86 pagesize again.
+ */
+#define VIRTIO_PCI_VRING_ALIGN 4096
+
+#endif /* VIRTIO_PCI_NO_LEGACY */
+
+/* The bit of the ISR which indicates a device configuration change */
+#define VIRTIO_PCI_ISR_CONFIG 0x2
+/* Vector value used to disable MSI for queue */
+#define VIRTIO_MSI_NO_VECTOR 0xffff
+
+#ifndef VIRTIO_PCI_NO_MODERN
+
+/* IDs for different capabilities. Must all exist. */
+
+/* Common configuration */
+#define VIRTIO_PCI_CAP_COMMON_CFG 1
+/* Notifications */
+#define VIRTIO_PCI_CAP_NOTIFY_CFG 2
+/* ISR access */
+#define VIRTIO_PCI_CAP_ISR_CFG 3
+/* Device specific configuration */
+#define VIRTIO_PCI_CAP_DEVICE_CFG 4
+/* PCI configuration access */
+#define VIRTIO_PCI_CAP_PCI_CFG 5
+
+/* This is the PCI capability header: */
+struct virtio_pci_cap {
+ __u8 cap_vndr; /* Generic PCI field: PCI_CAP_ID_VNDR */
+ __u8 cap_next; /* Generic PCI field: next ptr */
+ __u8 cap_len; /* Generic PCI field: capability length */
+ __u8 cfg_type; /* Identifies the structure */
+ __u8 bar; /* Where to find it */
+ __u8 padding[3]; /* Pad to full dword */
+ __le32 offset; /* Offset within bar */
+ __le32 length; /* Length of the structure, in bytes */
+};
+
+struct virtio_pci_notify_cap {
+ struct virtio_pci_cap cap;
+ __le32 notify_off_multiplier; /* Multiplier for queue_notify_off */
+};
+
+/* Fields in VIRTIO_PCI_CAP_COMMON_CFG: */
+struct virtio_pci_common_cfg {
+ /* About the whole device */
+ __le32 device_feature_select; /* read-write */
+ __le32 device_feature; /* read-only */
+ __le32 guest_feature_select; /* read-write */
+ __le32 guest_feature; /* read-write */
+ __le16 msix_config; /* read-write */
+ __le16 num_queues; /* read-only */
+ __u8 device_status; /* read-write */
+ __u8 config_generation; /* read-only */
+
+ /* About a specific virtqueue */
+ __le16 queue_select; /* read-write */
+ __le16 queue_size; /* read-write, power of 2 */
+ __le16 queue_msix_vector; /* read-write */
+ __le16 queue_enable; /* read-write */
+ __le16 queue_notify_off; /* read-only */
+ __le32 queue_desc_lo; /* read-write */
+ __le32 queue_desc_hi; /* read-write */
+ __le32 queue_avail_lo; /* read-write */
+ __le32 queue_avail_hi; /* read-write */
+ __le32 queue_used_lo; /* read-write */
+ __le32 queue_used_hi; /* read-write */
+};
+
+/* Fields in VIRTIO_PCI_CAP_PCI_CFG: */
+struct virtio_pci_cfg_cap {
+ struct virtio_pci_cap cap;
+ __u8 pci_cfg_data[4]; /* Data for BAR access */
+};
+
+/* Macro versions of offsets for the Old Timers! */
+#define VIRTIO_PCI_CAP_VNDR 0
+#define VIRTIO_PCI_CAP_NEXT 1
+#define VIRTIO_PCI_CAP_LEN 2
+#define VIRTIO_PCI_CAP_CFG_TYPE 3
+#define VIRTIO_PCI_CAP_BAR 4
+#define VIRTIO_PCI_CAP_OFFSET 8
+#define VIRTIO_PCI_CAP_LENGTH 12
+
+#define VIRTIO_PCI_NOTIFY_CAP_MULT 16
+
+#define VIRTIO_PCI_COMMON_DFSELECT 0
+#define VIRTIO_PCI_COMMON_DF 4
+#define VIRTIO_PCI_COMMON_GFSELECT 8
+#define VIRTIO_PCI_COMMON_GF 12
+#define VIRTIO_PCI_COMMON_MSIX 16
+#define VIRTIO_PCI_COMMON_NUMQ 18
+#define VIRTIO_PCI_COMMON_STATUS 20
+#define VIRTIO_PCI_COMMON_CFGGENERATION 21
+#define VIRTIO_PCI_COMMON_Q_SELECT 22
+#define VIRTIO_PCI_COMMON_Q_SIZE 24
+#define VIRTIO_PCI_COMMON_Q_MSIX 26
+#define VIRTIO_PCI_COMMON_Q_ENABLE 28
+#define VIRTIO_PCI_COMMON_Q_NOFF 30
+#define VIRTIO_PCI_COMMON_Q_DESCLO 32
+#define VIRTIO_PCI_COMMON_Q_DESCHI 36
+#define VIRTIO_PCI_COMMON_Q_AVAILLO 40
+#define VIRTIO_PCI_COMMON_Q_AVAILHI 44
+#define VIRTIO_PCI_COMMON_Q_USEDLO 48
+#define VIRTIO_PCI_COMMON_Q_USEDHI 52
+
+#endif /* VIRTIO_PCI_NO_MODERN */
+
+#endif /* _LINUX_VIRTIO_PCI_H */
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 22/27] x86: qemu: Imply virtio PCI transport and device drivers
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (20 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 21/27] virtio: Add virtio over pci transport driver Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 23/27] dm: pci: Add APIs to find next capability and extended capability Bin Meng
` (5 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
Add virtio drivers for QEMU x86 targets.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
board/emulation/qemu-x86/Kconfig | 3 +++
1 file changed, 3 insertions(+)
diff --git a/board/emulation/qemu-x86/Kconfig b/board/emulation/qemu-x86/Kconfig
index 41a27dd..6d19299 100644
--- a/board/emulation/qemu-x86/Kconfig
+++ b/board/emulation/qemu-x86/Kconfig
@@ -21,5 +21,8 @@ config BOARD_SPECIFIC_OPTIONS # dummy
select X86_RESET_VECTOR
select QEMU
select BOARD_ROMSIZE_KB_1024
+ imply VIRTIO_PCI
+ imply VIRTIO_NET
+ imply VIRTIO_BLK
endif
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 23/27] dm: pci: Add APIs to find next capability and extended capability
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (21 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 22/27] x86: qemu: Imply virtio PCI transport and device drivers Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 24/27] test: dm: pci: Add cases for finding next PCI capability APIs Bin Meng
` (4 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
This introduces two new APIs dm_pci_find_next_capability() and
dm_pci_find_next_ext_capability() to get PCI capability address
and PCI express extended capability address for a given PCI device
starting from a given offset.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/pci/pci-uclass.c | 48 ++++++++++++++++++++++++++++++++----------------
include/pci.h | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 80 insertions(+), 16 deletions(-)
diff --git a/drivers/pci/pci-uclass.c b/drivers/pci/pci-uclass.c
index eb118f3..a100e16 100644
--- a/drivers/pci/pci-uclass.c
+++ b/drivers/pci/pci-uclass.c
@@ -1318,26 +1318,13 @@ void *dm_pci_map_bar(struct udevice *dev, int bar, int flags)
return dm_pci_bus_to_virt(dev, pci_bus_addr, flags, 0, MAP_NOCACHE);
}
-int dm_pci_find_capability(struct udevice *dev, int cap)
+int dm_pci_find_next_capability(struct udevice *dev, u8 start, int cap)
{
- u16 status;
- u8 header_type;
int ttl = PCI_FIND_CAP_TTL;
+ u8 pos = start;
u8 id;
u16 ent;
- u8 pos;
- dm_pci_read_config16(dev, PCI_STATUS, &status);
- if (!(status & PCI_STATUS_CAP_LIST))
- return 0;
-
- dm_pci_read_config8(dev, PCI_HEADER_TYPE, &header_type);
- if ((header_type & 0x7f) == PCI_HEADER_TYPE_CARDBUS)
- pos = PCI_CB_CAPABILITY_LIST;
- else
- pos = PCI_CAPABILITY_LIST;
-
- dm_pci_read_config8(dev, pos, &pos);
while (ttl--) {
if (pos < PCI_STD_HEADER_SIZEOF)
break;
@@ -1355,7 +1342,28 @@ int dm_pci_find_capability(struct udevice *dev, int cap)
return 0;
}
-int dm_pci_find_ext_capability(struct udevice *dev, int cap)
+int dm_pci_find_capability(struct udevice *dev, int cap)
+{
+ u16 status;
+ u8 header_type;
+ u8 pos;
+
+ dm_pci_read_config16(dev, PCI_STATUS, &status);
+ if (!(status & PCI_STATUS_CAP_LIST))
+ return 0;
+
+ dm_pci_read_config8(dev, PCI_HEADER_TYPE, &header_type);
+ if ((header_type & 0x7f) == PCI_HEADER_TYPE_CARDBUS)
+ pos = PCI_CB_CAPABILITY_LIST;
+ else
+ pos = PCI_CAPABILITY_LIST;
+
+ dm_pci_read_config8(dev, pos, &pos);
+
+ return dm_pci_find_next_capability(dev, pos, cap);
+}
+
+int dm_pci_find_next_ext_capability(struct udevice *dev, int start, int cap)
{
u32 header;
int ttl;
@@ -1364,6 +1372,9 @@ int dm_pci_find_ext_capability(struct udevice *dev, int cap)
/* minimum 8 bytes per capability */
ttl = (PCI_CFG_SPACE_EXP_SIZE - PCI_CFG_SPACE_SIZE) / 8;
+ if (start)
+ pos = start;
+
dm_pci_read_config32(dev, pos, &header);
/*
* If we have no capabilities, this is indicated by cap ID,
@@ -1386,6 +1397,11 @@ int dm_pci_find_ext_capability(struct udevice *dev, int cap)
return 0;
}
+int dm_pci_find_ext_capability(struct udevice *dev, int cap)
+{
+ return dm_pci_find_next_ext_capability(dev, 0, cap);
+}
+
UCLASS_DRIVER(pci) = {
.id = UCLASS_PCI,
.name = "pci",
diff --git a/include/pci.h b/include/pci.h
index 938a839..785d7d2 100644
--- a/include/pci.h
+++ b/include/pci.h
@@ -1313,6 +1313,29 @@ pci_addr_t dm_pci_phys_to_bus(struct udevice *dev, phys_addr_t addr,
void *dm_pci_map_bar(struct udevice *dev, int bar, int flags);
/**
+ * dm_pci_find_next_capability() - find a capability starting from an offset
+ *
+ * Tell if a device supports a given PCI capability. Returns the
+ * address of the requested capability structure within the device's
+ * PCI configuration space or 0 in case the device does not support it.
+ *
+ * Possible values for @cap:
+ *
+ * %PCI_CAP_ID_MSI Message Signalled Interrupts
+ * %PCI_CAP_ID_PCIX PCI-X
+ * %PCI_CAP_ID_EXP PCI Express
+ * %PCI_CAP_ID_MSIX MSI-X
+ *
+ * See PCI_CAP_ID_xxx for the complete capability ID codes.
+ *
+ * @dev: PCI device to query
+ * @start: offset to start from
+ * @cap: capability code
+ * @return: capability address or 0 if not supported
+ */
+int dm_pci_find_next_capability(struct udevice *dev, u8 start, int cap);
+
+/**
* dm_pci_find_capability() - find a capability
*
* Tell if a device supports a given PCI capability. Returns the
@@ -1335,6 +1358,31 @@ void *dm_pci_map_bar(struct udevice *dev, int bar, int flags);
int dm_pci_find_capability(struct udevice *dev, int cap);
/**
+ * dm_pci_find_next_ext_capability() - find an extended capability
+ * starting from an offset
+ *
+ * Tell if a device supports a given PCI express extended capability.
+ * Returns the address of the requested extended capability structure
+ * within the device's PCI configuration space or 0 in case the device
+ * does not support it.
+ *
+ * Possible values for @cap:
+ *
+ * %PCI_EXT_CAP_ID_ERR Advanced Error Reporting
+ * %PCI_EXT_CAP_ID_VC Virtual Channel
+ * %PCI_EXT_CAP_ID_DSN Device Serial Number
+ * %PCI_EXT_CAP_ID_PWR Power Budgeting
+ *
+ * See PCI_EXT_CAP_ID_xxx for the complete extended capability ID codes.
+ *
+ * @dev: PCI device to query
+ * @start: offset to start from
+ * @cap: extended capability code
+ * @return: extended capability address or 0 if not supported
+ */
+int dm_pci_find_next_ext_capability(struct udevice *dev, int start, int cap);
+
+/**
* dm_pci_find_ext_capability() - find an extended capability
*
* Tell if a device supports a given PCI express extended capability.
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 24/27] test: dm: pci: Add cases for finding next PCI capability APIs
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (22 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 23/27] dm: pci: Add APIs to find next capability and extended capability Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 25/27] virtio: pci: Support non-legacy PCI transport device Bin Meng
` (3 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
Add test cases to cover the two newly added PCI APIs:
dm_pci_find_next_capability() & dm_pci_find_next_ext_capability().
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
test/dm/pci.c | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/test/dm/pci.c b/test/dm/pci.c
index 8699700..f645b8b 100644
--- a/test/dm/pci.c
+++ b/test/dm/pci.c
@@ -206,6 +206,16 @@ static int dm_test_pci_cap(struct unit_test_state *uts)
cap = dm_pci_find_capability(swap, PCI_CAP_ID_PCIX);
ut_asserteq(0, cap);
+ /* look up PCI_CAP_ID_MSIX starting from PCI_CAP_ID_PM_OFFSET */
+ cap = dm_pci_find_next_capability(swap, PCI_CAP_ID_PM_OFFSET,
+ PCI_CAP_ID_MSIX);
+ ut_asserteq(PCI_CAP_ID_MSIX_OFFSET, cap);
+
+ /* look up PCI_CAP_ID_VNDR starting from PCI_CAP_ID_EXP_OFFSET */
+ cap = dm_pci_find_next_capability(swap, PCI_CAP_ID_EXP_OFFSET,
+ PCI_CAP_ID_VNDR);
+ ut_asserteq(0, cap);
+
ut_assertok(uclass_get_device_by_seq(UCLASS_PCI, 1, &bus));
ut_assertok(dm_pci_bus_find_bdf(PCI_BDF(1, 0x08, 0), &swap));
@@ -217,6 +227,16 @@ static int dm_test_pci_cap(struct unit_test_state *uts)
cap = dm_pci_find_ext_capability(swap, PCI_EXT_CAP_ID_SRIOV);
ut_asserteq(0, cap);
+ /* look up PCI_EXT_CAP_ID_DSN starting from PCI_EXT_CAP_ID_ERR_OFFSET */
+ cap = dm_pci_find_next_ext_capability(swap, PCI_EXT_CAP_ID_ERR_OFFSET,
+ PCI_EXT_CAP_ID_DSN);
+ ut_asserteq(PCI_EXT_CAP_ID_DSN_OFFSET, cap);
+
+ /* look up PCI_EXT_CAP_ID_RCRB starting from PCI_EXT_CAP_ID_VC_OFFSET */
+ cap = dm_pci_find_next_ext_capability(swap, PCI_EXT_CAP_ID_VC_OFFSET,
+ PCI_EXT_CAP_ID_RCRB);
+ ut_asserteq(0, cap);
+
return 0;
}
DM_TEST(dm_test_pci_cap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 25/27] virtio: pci: Support non-legacy PCI transport device
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (23 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 24/27] test: dm: pci: Add cases for finding next PCI capability APIs Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 26/27] virtio: net: Support non-legacy device Bin Meng
` (2 subsequent siblings)
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
By default QEMU creates legacy PCI transport devices, but we can
ask QEMU to create non-legacy one if we pass additional device
property/value pairs in the command line:
-device virtio-blk-pci,disable-legacy=true,disable-modern=false
This adds a new driver driver to support non-legacy (modern) device
mode. Previous driver/file name is changed accordingly.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/virtio/Makefile | 2 +-
.../virtio/{virtio_pci.c => virtio_pci_legacy.c} | 6 +-
drivers/virtio/virtio_pci_modern.c | 612 +++++++++++++++++++++
3 files changed, 616 insertions(+), 4 deletions(-)
rename drivers/virtio/{virtio_pci.c => virtio_pci_legacy.c} (98%)
create mode 100644 drivers/virtio/virtio_pci_modern.c
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
index 5ee6183..072fb56 100644
--- a/drivers/virtio/Makefile
+++ b/drivers/virtio/Makefile
@@ -5,6 +5,6 @@
obj-y += virtio-uclass.o virtio_ring.o
obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o
-obj-$(CONFIG_VIRTIO_PCI) += virtio_pci.o
+obj-$(CONFIG_VIRTIO_PCI) += virtio_pci_legacy.o virtio_pci_modern.o
obj-$(CONFIG_VIRTIO_NET) += virtio_net.o
obj-$(CONFIG_VIRTIO_BLK) += virtio_blk.o
diff --git a/drivers/virtio/virtio_pci.c b/drivers/virtio/virtio_pci_legacy.c
similarity index 98%
rename from drivers/virtio/virtio_pci.c
rename to drivers/virtio/virtio_pci_legacy.c
index 12ecd84..ab40210 100644
--- a/drivers/virtio/virtio_pci.c
+++ b/drivers/virtio/virtio_pci_legacy.c
@@ -15,7 +15,7 @@
#include <linux/io.h>
#include "virtio_pci.h"
-#define VIRTIO_PCI_DRV_NAME "virtio-pci"
+#define VIRTIO_PCI_DRV_NAME "virtio-pci.l"
/* PCI device ID in the range 0x1000 to 0x103f */
#define VIRTIO_PCI_VENDOR_ID 0x1af4
@@ -340,7 +340,7 @@ static const struct dm_virtio_ops virtio_pci_ops = {
.notify = virtio_pci_notify,
};
-U_BOOT_DRIVER(virtio_pci) = {
+U_BOOT_DRIVER(virtio_pci_legacy) = {
.name = VIRTIO_PCI_DRV_NAME,
.id = UCLASS_VIRTIO,
.ops = &virtio_pci_ops,
@@ -417,4 +417,4 @@ static struct pci_device_id virtio_pci_supported[] = {
{},
};
-U_BOOT_PCI_DEVICE(virtio_pci, virtio_pci_supported);
+U_BOOT_PCI_DEVICE(virtio_pci_legacy, virtio_pci_supported);
diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
new file mode 100644
index 0000000..0241f1d
--- /dev/null
+++ b/drivers/virtio/virtio_pci_modern.c
@@ -0,0 +1,612 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+ *
+ * VirtIO PCI bus transport driver
+ * Ported from Linux drivers/virtio/virtio_pci*.c
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <virtio.h>
+#include <virtio_ring.h>
+#include <dm/device.h>
+#include <linux/compat.h>
+#include <linux/io.h>
+#include "virtio_pci.h"
+
+#define VIRTIO_PCI_DRV_NAME "virtio-pci.m"
+
+/* PCI device ID in the range 0x1040 to 0x107f */
+#define VIRTIO_PCI_VENDOR_ID 0x1af4
+#define VIRTIO_PCI_DEVICE_ID00 0x1040
+#define VIRTIO_PCI_DEVICE_ID01 0x1041
+#define VIRTIO_PCI_DEVICE_ID02 0x1042
+#define VIRTIO_PCI_DEVICE_ID03 0x1043
+#define VIRTIO_PCI_DEVICE_ID04 0x1044
+#define VIRTIO_PCI_DEVICE_ID05 0x1045
+#define VIRTIO_PCI_DEVICE_ID06 0x1046
+#define VIRTIO_PCI_DEVICE_ID07 0x1047
+#define VIRTIO_PCI_DEVICE_ID08 0x1048
+#define VIRTIO_PCI_DEVICE_ID09 0x1049
+#define VIRTIO_PCI_DEVICE_ID0A 0x104a
+#define VIRTIO_PCI_DEVICE_ID0B 0x104b
+#define VIRTIO_PCI_DEVICE_ID0C 0x104c
+#define VIRTIO_PCI_DEVICE_ID0D 0x104d
+#define VIRTIO_PCI_DEVICE_ID0E 0x104e
+#define VIRTIO_PCI_DEVICE_ID0F 0x104f
+#define VIRTIO_PCI_DEVICE_ID10 0x1050
+#define VIRTIO_PCI_DEVICE_ID11 0x1051
+#define VIRTIO_PCI_DEVICE_ID12 0x1052
+#define VIRTIO_PCI_DEVICE_ID13 0x1053
+#define VIRTIO_PCI_DEVICE_ID14 0x1054
+#define VIRTIO_PCI_DEVICE_ID15 0x1055
+#define VIRTIO_PCI_DEVICE_ID16 0x1056
+#define VIRTIO_PCI_DEVICE_ID17 0x1057
+#define VIRTIO_PCI_DEVICE_ID18 0x1058
+#define VIRTIO_PCI_DEVICE_ID19 0x1059
+#define VIRTIO_PCI_DEVICE_ID1A 0x105a
+#define VIRTIO_PCI_DEVICE_ID1B 0x105b
+#define VIRTIO_PCI_DEVICE_ID1C 0x105c
+#define VIRTIO_PCI_DEVICE_ID1D 0x105d
+#define VIRTIO_PCI_DEVICE_ID1E 0x105e
+#define VIRTIO_PCI_DEVICE_ID1F 0x105f
+#define VIRTIO_PCI_DEVICE_ID20 0x1060
+#define VIRTIO_PCI_DEVICE_ID21 0x1061
+#define VIRTIO_PCI_DEVICE_ID22 0x1062
+#define VIRTIO_PCI_DEVICE_ID23 0x1063
+#define VIRTIO_PCI_DEVICE_ID24 0x1064
+#define VIRTIO_PCI_DEVICE_ID25 0x1065
+#define VIRTIO_PCI_DEVICE_ID26 0x1066
+#define VIRTIO_PCI_DEVICE_ID27 0x1067
+#define VIRTIO_PCI_DEVICE_ID28 0x1068
+#define VIRTIO_PCI_DEVICE_ID29 0x1069
+#define VIRTIO_PCI_DEVICE_ID2A 0x106a
+#define VIRTIO_PCI_DEVICE_ID2B 0x106b
+#define VIRTIO_PCI_DEVICE_ID2C 0x106c
+#define VIRTIO_PCI_DEVICE_ID2D 0x106d
+#define VIRTIO_PCI_DEVICE_ID2E 0x106e
+#define VIRTIO_PCI_DEVICE_ID2F 0x106f
+#define VIRTIO_PCI_DEVICE_ID30 0x1070
+#define VIRTIO_PCI_DEVICE_ID31 0x1071
+#define VIRTIO_PCI_DEVICE_ID32 0x1072
+#define VIRTIO_PCI_DEVICE_ID33 0x1073
+#define VIRTIO_PCI_DEVICE_ID34 0x1074
+#define VIRTIO_PCI_DEVICE_ID35 0x1075
+#define VIRTIO_PCI_DEVICE_ID36 0x1076
+#define VIRTIO_PCI_DEVICE_ID37 0x1077
+#define VIRTIO_PCI_DEVICE_ID38 0x1078
+#define VIRTIO_PCI_DEVICE_ID39 0x1079
+#define VIRTIO_PCI_DEVICE_ID3A 0x107a
+#define VIRTIO_PCI_DEVICE_ID3B 0x107b
+#define VIRTIO_PCI_DEVICE_ID3C 0x107c
+#define VIRTIO_PCI_DEVICE_ID3D 0x107d
+#define VIRTIO_PCI_DEVICE_ID3E 0x107e
+#define VIRTIO_PCI_DEVICE_ID3F 0x107f
+
+/**
+ * virtio pci transport driver private data
+ *
+ * @common: pci transport device common register block base
+ * @notify_base: pci transport device notify register block base
+ * @device: pci transport device device-specific register block base
+ * @device_len: pci transport device device-specific register block length
+ * @notify_offset_multiplier: multiply queue_notify_off by this value
+ */
+struct virtio_pci_priv {
+ struct virtio_pci_common_cfg __iomem *common;
+ void __iomem *notify_base;
+ void __iomem *device;
+ size_t device_len;
+ u32 notify_offset_multiplier;
+};
+
+static int virtio_pci_get_config(struct udevice *udev, unsigned int offset,
+ void *buf, unsigned int len)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ u8 b;
+ __le16 w;
+ __le32 l;
+
+ WARN_ON(offset + len > priv->device_len);
+
+ switch (len) {
+ case 1:
+ b = ioread8(priv->device + offset);
+ memcpy(buf, &b, sizeof(b));
+ break;
+ case 2:
+ w = cpu_to_le16(ioread16(priv->device + offset));
+ memcpy(buf, &w, sizeof(w));
+ break;
+ case 4:
+ l = cpu_to_le32(ioread32(priv->device + offset));
+ memcpy(buf, &l, sizeof(l));
+ break;
+ case 8:
+ l = cpu_to_le32(ioread32(priv->device + offset));
+ memcpy(buf, &l, sizeof(l));
+ l = cpu_to_le32(ioread32(priv->device + offset + sizeof(l)));
+ memcpy(buf + sizeof(l), &l, sizeof(l));
+ break;
+ default:
+ WARN_ON(true);
+ }
+
+ return 0;
+}
+
+static int virtio_pci_set_config(struct udevice *udev, unsigned int offset,
+ const void *buf, unsigned int len)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ u8 b;
+ __le16 w;
+ __le32 l;
+
+ WARN_ON(offset + len > priv->device_len);
+
+ switch (len) {
+ case 1:
+ memcpy(&b, buf, sizeof(b));
+ iowrite8(b, priv->device + offset);
+ break;
+ case 2:
+ memcpy(&w, buf, sizeof(w));
+ iowrite16(le16_to_cpu(w), priv->device + offset);
+ break;
+ case 4:
+ memcpy(&l, buf, sizeof(l));
+ iowrite32(le32_to_cpu(l), priv->device + offset);
+ break;
+ case 8:
+ memcpy(&l, buf, sizeof(l));
+ iowrite32(le32_to_cpu(l), priv->device + offset);
+ memcpy(&l, buf + sizeof(l), sizeof(l));
+ iowrite32(le32_to_cpu(l), priv->device + offset + sizeof(l));
+ break;
+ default:
+ WARN_ON(true);
+ }
+
+ return 0;
+}
+
+static int virtio_pci_generation(struct udevice *udev, u32 *counter)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ *counter = ioread8(&priv->common->config_generation);
+
+ return 0;
+}
+
+static int virtio_pci_get_status(struct udevice *udev, u8 *status)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ *status = ioread8(&priv->common->device_status);
+
+ return 0;
+}
+
+static int virtio_pci_set_status(struct udevice *udev, u8 status)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ /* We should never be setting status to 0 */
+ WARN_ON(status == 0);
+
+ iowrite8(status, &priv->common->device_status);
+
+ return 0;
+}
+
+static int virtio_pci_reset(struct udevice *udev)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ /* 0 status means a reset */
+ iowrite8(0, &priv->common->device_status);
+
+ /*
+ * After writing 0 to device_status, the driver MUST wait for a read
+ * of device_status to return 0 before reinitializing the device.
+ * This will flush out the status write, and flush in device writes,
+ * including MSi-X interrupts, if any.
+ */
+ while (ioread8(&priv->common->device_status))
+ udelay(1000);
+
+ return 0;
+}
+
+static int virtio_pci_get_features(struct udevice *udev, u64 *features)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+
+ iowrite32(0, &priv->common->device_feature_select);
+ *features = ioread32(&priv->common->device_feature);
+ iowrite32(1, &priv->common->device_feature_select);
+ *features |= ((u64)ioread32(&priv->common->device_feature) << 32);
+
+ return 0;
+}
+
+static int virtio_pci_set_features(struct udevice *udev)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+
+ if (!__virtio_test_bit(udev, VIRTIO_F_VERSION_1)) {
+ debug("virtio: device uses modern interface but does not have VIRTIO_F_VERSION_1\n");
+ return -EINVAL;
+ }
+
+ iowrite32(0, &priv->common->guest_feature_select);
+ iowrite32((u32)uc_priv->features, &priv->common->guest_feature);
+ iowrite32(1, &priv->common->guest_feature_select);
+ iowrite32(uc_priv->features >> 32, &priv->common->guest_feature);
+
+ return 0;
+}
+
+static struct virtqueue *virtio_pci_setup_vq(struct udevice *udev,
+ unsigned int index)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ struct virtio_pci_common_cfg __iomem *cfg = priv->common;
+ struct virtqueue *vq;
+ u16 num;
+ u64 addr;
+ int err;
+
+ if (index >= ioread16(&cfg->num_queues))
+ return ERR_PTR(-ENOENT);
+
+ /* Select the queue we're interested in */
+ iowrite16(index, &cfg->queue_select);
+
+ /* Check if queue is either not available or already active */
+ num = ioread16(&cfg->queue_size);
+ if (!num || ioread16(&cfg->queue_enable))
+ return ERR_PTR(-ENOENT);
+
+ if (num & (num - 1)) {
+ printf("(%s): bad queue size %u", udev->name, num);
+ return ERR_PTR(-EINVAL);
+ }
+
+ /* Create the vring */
+ vq = vring_create_virtqueue(index, num, VIRTIO_PCI_VRING_ALIGN, udev);
+ if (!vq) {
+ err = -ENOMEM;
+ goto error_available;
+ }
+
+ /* Activate the queue */
+ iowrite16(virtqueue_get_vring_size(vq), &cfg->queue_size);
+
+ addr = virtqueue_get_desc_addr(vq);
+ iowrite32((u32)addr, &cfg->queue_desc_lo);
+ iowrite32(addr >> 32, &cfg->queue_desc_hi);
+
+ addr = virtqueue_get_avail_addr(vq);
+ iowrite32((u32)addr, &cfg->queue_avail_lo);
+ iowrite32(addr >> 32, &cfg->queue_avail_hi);
+
+ addr = virtqueue_get_used_addr(vq);
+ iowrite32((u32)addr, &cfg->queue_used_lo);
+ iowrite32(addr >> 32, &cfg->queue_used_hi);
+
+ iowrite16(1, &cfg->queue_enable);
+
+ return vq;
+
+error_available:
+ return ERR_PTR(err);
+}
+
+static void virtio_pci_del_vq(struct virtqueue *vq)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(vq->vdev);
+ unsigned int index = vq->index;
+
+ iowrite16(index, &priv->common->queue_select);
+
+ /* Select and deactivate the queue */
+ iowrite16(0, &priv->common->queue_enable);
+
+ vring_del_virtqueue(vq);
+}
+
+static int virtio_pci_del_vqs(struct udevice *udev)
+{
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+ struct virtqueue *vq, *n;
+
+ list_for_each_entry_safe(vq, n, &uc_priv->vqs, list)
+ virtio_pci_del_vq(vq);
+
+ return 0;
+}
+
+static int virtio_pci_find_vqs(struct udevice *udev, unsigned int nvqs,
+ struct virtqueue *vqs[])
+{
+ int i;
+
+ for (i = 0; i < nvqs; ++i) {
+ vqs[i] = virtio_pci_setup_vq(udev, i);
+ if (IS_ERR(vqs[i])) {
+ virtio_pci_del_vqs(udev);
+ return PTR_ERR(vqs[i]);
+ }
+ }
+
+ return 0;
+}
+
+static int virtio_pci_notify(struct udevice *udev, struct virtqueue *vq)
+{
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ u16 off;
+
+ /* Select the queue we're interested in */
+ iowrite16(vq->index, &priv->common->queue_select);
+
+ /* get offset of notification word for this vq */
+ off = ioread16(&priv->common->queue_notify_off);
+
+ /*
+ * We write the queue's selector into the notification register
+ * to signal the other end
+ */
+ iowrite16(vq->index,
+ priv->notify_base + off * priv->notify_offset_multiplier);
+
+ return 0;
+}
+
+/**
+ * virtio_pci_find_capability - walk capabilities to find device info
+ *
+ * @udev: the transport device
+ * @cfg_type: the VIRTIO_PCI_CAP_* value we seek
+ *
+ * @return offset of the configuration structure
+ */
+static int virtio_pci_find_capability(struct udevice *udev, u8 cfg_type)
+{
+ int pos;
+ int offset;
+ u8 type, bar;
+ u16 next;
+
+ for (pos = dm_pci_find_capability(udev, PCI_CAP_ID_VNDR);
+ pos > 0;
+ pos = dm_pci_find_next_capability(udev, pos, PCI_CAP_ID_VNDR)) {
+ offset = pos + offsetof(struct virtio_pci_cap, cfg_type);
+ dm_pci_read_config8(udev, offset, &type);
+ offset = pos + offsetof(struct virtio_pci_cap, bar);
+ dm_pci_read_config8(udev, offset, &bar);
+
+ /* Ignore structures with reserved BAR values */
+ if (bar > 0x5)
+ continue;
+
+ if (type == cfg_type)
+ return pos;
+
+ dm_pci_read_config16(udev, pos, &next);
+ pos = (next >> 8);
+ }
+
+ return 0;
+}
+
+/**
+ * virtio_pci_map_capability - map base address of the capability
+ *
+ * @udev: the transport device
+ * @off: offset of the configuration structure
+ *
+ * @return base address of the capability
+ */
+static void __iomem *virtio_pci_map_capability(struct udevice *udev, int off)
+{
+ u8 bar;
+ u32 offset;
+ ulong base;
+ void __iomem *p;
+
+ if (!off)
+ return NULL;
+
+ offset = off + offsetof(struct virtio_pci_cap, bar);
+ dm_pci_read_config8(udev, offset, &bar);
+ offset = off + offsetof(struct virtio_pci_cap, offset);
+ dm_pci_read_config32(udev, offset, &offset);
+
+ /*
+ * TODO: adding 64-bit BAR support
+ *
+ * Per spec, the BAR is permitted to be either 32-bit or 64-bit.
+ * For simplicity, only read the BAR address as 32-bit.
+ */
+ base = dm_pci_read_bar32(udev, bar);
+ p = (void __iomem *)base + offset;
+
+ return p;
+}
+
+static int virtio_pci_bind(struct udevice *udev)
+{
+ static int num_devs;
+ char name[20];
+
+ /* Create a unique device name */
+ sprintf(name, "%s#%u", VIRTIO_PCI_DRV_NAME, num_devs++);
+ device_set_name(udev, name);
+
+ return 0;
+}
+
+static int virtio_pci_probe(struct udevice *udev)
+{
+ struct pci_child_platdata *pplat = dev_get_parent_platdata(udev);
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
+ struct virtio_pci_priv *priv = dev_get_priv(udev);
+ u16 subvendor;
+ u8 revision;
+ int common, notify, device;
+ int offset;
+
+ /* We only own devices >= 0x1040 and <= 0x107f: leave the rest. */
+ if (pplat->device < 0x1040 || pplat->device > 0x107f)
+ return -ENODEV;
+
+ /* Transitional devices must not have a PCI revision ID of 0 */
+ dm_pci_read_config8(udev, PCI_REVISION_ID, &revision);
+
+ /* Modern devices: simply use PCI device id, but start from 0x1040. */
+ uc_priv->device = pplat->device - 0x1040;
+ dm_pci_read_config16(udev, PCI_SUBSYSTEM_VENDOR_ID, &subvendor);
+ uc_priv->vendor = subvendor;
+
+ /* Check for a common config: if not, use legacy mode (bar 0) */
+ common = virtio_pci_find_capability(udev, VIRTIO_PCI_CAP_COMMON_CFG);
+ if (!common) {
+ printf("(%s): leaving for legacy driver\n", udev->name);
+ return -ENODEV;
+ }
+
+ /* If common is there, notify should be too */
+ notify = virtio_pci_find_capability(udev, VIRTIO_PCI_CAP_NOTIFY_CFG);
+ if (!notify) {
+ printf("(%s): missing capabilities %i/%i\n", udev->name,
+ common, notify);
+ return -EINVAL;
+ }
+
+ /*
+ * Device capability is only mandatory for devices that have
+ * device-specific configuration.
+ */
+ device = virtio_pci_find_capability(udev, VIRTIO_PCI_CAP_DEVICE_CFG);
+ if (device) {
+ offset = notify + offsetof(struct virtio_pci_cap, length);
+ dm_pci_read_config32(udev, offset, &priv->device_len);
+ }
+
+ /* Map configuration structures */
+ priv->common = virtio_pci_map_capability(udev, common);
+ priv->notify_base = virtio_pci_map_capability(udev, notify);
+ priv->device = virtio_pci_map_capability(udev, device);
+ debug("(%p): common @ %p, notify base @ %p, device @ %p\n",
+ udev, priv->common, priv->notify_base, priv->device);
+
+ /* Read notify_off_multiplier from config space */
+ offset = notify + offsetof(struct virtio_pci_notify_cap,
+ notify_off_multiplier);
+ dm_pci_read_config32(udev, offset, &priv->notify_offset_multiplier);
+
+ debug("(%s): device (%d) vendor (%08x) version (%d)\n", udev->name,
+ uc_priv->device, uc_priv->vendor, revision);
+
+ return 0;
+}
+
+static const struct dm_virtio_ops virtio_pci_ops = {
+ .get_config = virtio_pci_get_config,
+ .set_config = virtio_pci_set_config,
+ .generation = virtio_pci_generation,
+ .get_status = virtio_pci_get_status,
+ .set_status = virtio_pci_set_status,
+ .reset = virtio_pci_reset,
+ .get_features = virtio_pci_get_features,
+ .set_features = virtio_pci_set_features,
+ .find_vqs = virtio_pci_find_vqs,
+ .del_vqs = virtio_pci_del_vqs,
+ .notify = virtio_pci_notify,
+};
+
+U_BOOT_DRIVER(virtio_pci_modern) = {
+ .name = VIRTIO_PCI_DRV_NAME,
+ .id = UCLASS_VIRTIO,
+ .ops = &virtio_pci_ops,
+ .bind = virtio_pci_bind,
+ .probe = virtio_pci_probe,
+ .priv_auto_alloc_size = sizeof(struct virtio_pci_priv),
+};
+
+static struct pci_device_id virtio_pci_supported[] = {
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID00) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID01) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID02) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID03) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID04) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID05) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID06) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID07) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID08) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID09) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0A) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0B) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0C) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0D) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0E) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID0F) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID10) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID11) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID12) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID13) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID14) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID15) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID16) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID17) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID18) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID19) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1A) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1B) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1C) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1D) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1E) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID1F) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID20) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID21) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID22) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID23) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID24) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID25) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID26) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID27) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID28) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID29) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2A) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2B) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2C) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2D) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2E) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID2F) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID30) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID31) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID32) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID33) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID34) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID35) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID36) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID37) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID38) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID39) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3A) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3B) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3C) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3D) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3E) },
+ { PCI_DEVICE(VIRTIO_PCI_VENDOR_ID, VIRTIO_PCI_DEVICE_ID3F) },
+ {},
+};
+
+U_BOOT_PCI_DEVICE(virtio_pci_modern, virtio_pci_supported);
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 26/27] virtio: net: Support non-legacy device
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (24 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 25/27] virtio: pci: Support non-legacy PCI transport device Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:43 ` Simon Glass
2018-10-15 21:59 ` Joe Hershberger
2018-09-23 13:42 ` [U-Boot] [PATCH 27/27] doc: Document virtio support Bin Meng
2018-09-27 13:43 ` [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Simon Glass
27 siblings, 2 replies; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
For v1.0 compliant device, it always assumes the member 'num_buffers'
exists in the struct virtio_net_hdr while the legacy driver only
presented 'num_buffers' when VIRTIO_NET_F_MRG_RXBUF was negotiated.
Without that feature the structure was 2 bytes shorter.
Update the driver to support the non-legacy device.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
drivers/virtio/virtio_net.c | 31 ++++++++++++++++++++++++++-----
1 file changed, 26 insertions(+), 5 deletions(-)
diff --git a/drivers/virtio/virtio_net.c b/drivers/virtio/virtio_net.c
index 1ab1513..080b0be 100644
--- a/drivers/virtio/virtio_net.c
+++ b/drivers/virtio/virtio_net.c
@@ -31,6 +31,7 @@ struct virtio_net_priv {
char rx_buff[VIRTIO_NET_NUM_RX_BUFS][VIRTIO_NET_RX_BUF_SIZE];
bool rx_running;
+ int net_hdr_len;
};
/*
@@ -76,12 +77,19 @@ static int virtio_net_send(struct udevice *dev, void *packet, int length)
{
struct virtio_net_priv *priv = dev_get_priv(dev);
struct virtio_net_hdr hdr;
- struct virtio_sg hdr_sg = { &hdr, sizeof(hdr) };
+ struct virtio_net_hdr_v1 hdr_v1;
+ struct virtio_sg hdr_sg;
struct virtio_sg data_sg = { packet, length };
struct virtio_sg *sgs[] = { &hdr_sg, &data_sg };
int ret;
- memset(&hdr, 0, sizeof(struct virtio_net_hdr));
+ if (priv->net_hdr_len == sizeof(struct virtio_net_hdr))
+ hdr_sg.addr = &hdr;
+ else
+ hdr_sg.addr = &hdr_v1;
+ hdr_sg.length = priv->net_hdr_len;
+
+ memset(hdr_sg.addr, 0, priv->net_hdr_len);
ret = virtqueue_add(priv->tx_vq, sgs, 2, 0);
if (ret)
@@ -107,14 +115,14 @@ static int virtio_net_recv(struct udevice *dev, int flags, uchar **packetp)
if (!buf)
return -EAGAIN;
- *packetp = buf + sizeof(struct virtio_net_hdr);
- return len - sizeof(struct virtio_net_hdr);
+ *packetp = buf + priv->net_hdr_len;
+ return len - priv->net_hdr_len;
}
static int virtio_net_free_pkt(struct udevice *dev, uchar *packet, int length)
{
struct virtio_net_priv *priv = dev_get_priv(dev);
- void *buf = packet - sizeof(struct virtio_net_hdr);
+ void *buf = packet - priv->net_hdr_len;
struct virtio_sg sg = { buf, VIRTIO_NET_RX_BUF_SIZE };
struct virtio_sg *sgs[] = { &sg };
@@ -185,12 +193,25 @@ static int virtio_net_bind(struct udevice *dev)
static int virtio_net_probe(struct udevice *dev)
{
struct virtio_net_priv *priv = dev_get_priv(dev);
+ struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(dev->parent);
int ret;
ret = virtio_find_vqs(dev, 2, priv->vqs);
if (ret < 0)
return ret;
+ /*
+ * For v1.0 compliant device, it always assumes the member
+ * 'num_buffers' exists in the struct virtio_net_hdr while
+ * the legacy driver only presented 'num_buffers' when
+ * VIRTIO_NET_F_MRG_RXBUF was negotiated. Without that feature
+ * the structure was 2 bytes shorter.
+ */
+ if (uc_priv->legacy)
+ priv->net_hdr_len = sizeof(struct virtio_net_hdr);
+ else
+ priv->net_hdr_len = sizeof(struct virtio_net_hdr_v1);
+
return 0;
}
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 27/27] doc: Document virtio support
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (25 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 26/27] virtio: net: Support non-legacy device Bin Meng
@ 2018-09-23 13:42 ` Bin Meng
2018-09-27 13:43 ` Simon Glass
2018-09-27 13:43 ` [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Simon Glass
27 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-09-23 13:42 UTC (permalink / raw)
To: u-boot
Add REAME.virtio to describe the information about U-Boot support for
VirtIO devices, including supported boards, build instructions, driver
details etc.
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
---
doc/README.virtio | 247 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 247 insertions(+)
create mode 100644 doc/README.virtio
diff --git a/doc/README.virtio b/doc/README.virtio
new file mode 100644
index 0000000..ad58fe8
--- /dev/null
+++ b/doc/README.virtio
@@ -0,0 +1,247 @@
+# SPDX-License-Identifier: GPL-2.0+
+#
+# Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
+
+VirtIO Support
+==============
+
+This document describes the information about U-Boot support for VirtIO [1]
+devices, including supported boards, build instructions, driver details etc.
+
+What's VirtIO?
+--------------
+VirtIO is a virtualization standard for network and disk device drivers where
+just the guest's device driver "knows" it is running in a virtual environment,
+and cooperates with the hypervisor. This enables guests to get high performance
+network and disk operations, and gives most of the performance benefits of
+paravirtualization. In the U-Boot case, the guest is U-Boot itself, while the
+virtual environment are normally QEMU [2] targets like ARM, RISC-V and x86.
+
+Status
+------
+VirtIO can use various different buses, aka transports as described in the
+spec. While VirtIO devices are commonly implemented as PCI devices on x86,
+embedded devices models like ARM/RISC-V, which does not normally come with
+PCI support might use simple memory mapped device (MMIO) instead of the PCI
+device. The memory mapped virtio device behaviour is based on the PCI device
+specification. Therefore most operations including device initialization,
+queues configuration and buffer transfers are nearly identical. Both MMIO
+and PCI transport options are supported in U-Boot.
+
+The VirtIO spec defines a lots of VirtIO device types, however at present only
+network and block device, the most two commonly used devices, are supported.
+
+The following QEMU targets are supported.
+
+ - qemu_arm_defconfig
+ - qemu_arm64_defconfig
+ - qemu-riscv32_defconfig
+ - qemu-riscv64_defconfig
+ - qemu-x86_defconfig
+ - qemu-x86_64_defconfig
+
+Note ARM and RISC-V targets are configured with VirtIO MMIO transport driver,
+and on x86 it's the PCI transport driver.
+
+Build Instructions
+------------------
+Building U-Boot for pre-configured QEMU targets is no different from others.
+For example, we can do the following with the CROSS_COMPILE environment
+variable being properly set to a working toolchain for ARM:
+
+ $ make qemu_arm_defconfig
+ $ make
+
+You can even create a QEMU ARM target with VirtIO devices showing up on both
+MMIO and PCI buses. In this case, you can enable the PCI transport driver
+from 'make menuconfig':
+
+Device Drivers --->
+ ...
+ VirtIO Drivers --->
+ ...
+ [*] PCI driver for virtio devices
+
+Other drivers are at the same location and can be tuned to suit the needs.
+
+Requirements
+------------
+It is required that QEMU v2.5.0+ should be used to test U-Boot VirtIO support
+on QEMU ARM and x86, and v2.12.0+ on QEMU RISC-V.
+
+Testing
+-------
+The following QEMU command line is used to get U-Boot up and running with
+VirtIO net and block devices on ARM.
+
+ $ qemu-system-arm -nographic -machine virt -bios u-boot.bin \
+ -netdev tap,ifname=tap0,id=net0 \
+ -device virtio-net-device,netdev=net0 \
+ -drive if=none,file=test.img,format=raw,id=hd0 \
+ -device virtio-blk-device,drive=hd0
+
+On x86, command is slightly different to create PCI VirtIO devices.
+
+ $ qemu-system-i386 -nographic -bios u-boot.rom \
+ -netdev tap,ifname=tap0,id=net0 \
+ -device virtio-net-pci,netdev=net0 \
+ -drive if=none,file=test.img,format=raw,id=hd0 \
+ -device virtio-blk-pci,drive=hd0
+
+Additional net and block devices can be created by appending more '-device'
+parameters. It is also possible to specify both MMIO and PCI VirtIO devices.
+For example, the following commnad creates 3 VirtIO devices, with 1 on MMIO
+and 2 on PCI bus.
+
+ $ qemu-system-arm -nographic -machine virt -bios u-boot.bin \
+ -netdev tap,ifname=tap0,id=net0 \
+ -device virtio-net-pci,netdev=net0 \
+ -drive if=none,file=test0.img,format=raw,id=hd0 \
+ -device virtio-blk-device,drive=hd0 \
+ -drive if=none,file=test1.img,format=raw,id=hd1 \
+ -device virtio-blk-pci,drive=hd1
+
+By default QEMU creates VirtIO legacy devices by default. To create non-legacy
+(aka modern) devices, pass additional device property/value pairs like below:
+
+ $ qemu-system-i386 -nographic -bios u-boot.rom \
+ -netdev tap,ifname=tap0,id=net0 \
+ -device virtio-net-pci,netdev=net0,disable-legacy=true,disable-modern=false \
+ -drive if=none,file=test.img,format=raw,id=hd0 \
+ -device virtio-blk-pci,drive=hd0,disable-legacy=true,disable-modern=false
+
+A 'virtio' command is provided in U-Boot shell.
+
+ => virtio
+ virtio - virtio block devices sub-system
+
+ Usage:
+ virtio scan - initialize virtio bus
+ virtio info - show all available virtio block devices
+ virtio device [dev] - show or set current virtio block device
+ virtio part [dev] - print partition table of one or all virtio block devices
+ virtio read addr blk# cnt - read `cnt' blocks starting at block
+ `blk#' to memory address `addr'
+ virtio write addr blk# cnt - write `cnt' blocks starting at block
+ `blk#' from memory address `addr'
+
+To probe all the VirtIO devices, type:
+
+ => virtio scan
+
+Then we can show the connected block device details by:
+
+ => virtio info
+ Device 0: QEMU VirtIO Block Device
+ Type: Hard Disk
+ Capacity: 4096.0 MB = 4.0 GB (8388608 x 512)
+
+And list the directories and files on the disk by:
+
+ => ls virtio 0 /
+ <DIR> 4096 .
+ <DIR> 4096 ..
+ <DIR> 16384 lost+found
+ <DIR> 4096 dev
+ <DIR> 4096 proc
+ <DIR> 4096 sys
+ <DIR> 4096 var
+ <DIR> 4096 etc
+ <DIR> 4096 usr
+ <SYM> 7 bin
+ <SYM> 8 sbin
+ <SYM> 7 lib
+ <SYM> 9 lib64
+ <DIR> 4096 run
+ <DIR> 4096 boot
+ <DIR> 4096 home
+ <DIR> 4096 media
+ <DIR> 4096 mnt
+ <DIR> 4096 opt
+ <DIR> 4096 root
+ <DIR> 4096 srv
+ <DIR> 4096 tmp
+ 0 .autorelabel
+
+Driver Internals
+----------------
+There are 3 level of drivers in the VirtIO driver family.
+
+ +---------------------------------------+
+ | virtio device drivers |
+ | +-------------+ +------------+ |
+ | | virtio-net | | virtio-blk | |
+ | +-------------+ +------------+ |
+ +---------------------------------------+
+ +---------------------------------------+
+ | virtio transport drivers |
+ | +-------------+ +------------+ |
+ | | virtio-mmio | | virtio-pci | |
+ | +-------------+ +------------+ |
+ +---------------------------------------+
+ +----------------------+
+ | virtio uclass driver |
+ +----------------------+
+
+The root one is the virtio uclass driver (virtio-uclass.c), which does lots of
+common stuff for the transport drivers (virtio_mmio.c, virtio_pci.c). The real
+virtio device is discovered in the transport driver's probe() method, and its
+device ID is saved in the virtio uclass's private data of the transport device.
+Then in the virtio uclass's post_probe() method, the real virtio device driver
+(virtio_net.c, virtio_blk.c) is bound if there is a match on the device ID.
+
+The child_post_bind(), child_pre_probe() and child_post_probe() methods of the
+virtio uclass driver help bring the virtio device driver online. They do things
+like acknowledging device, feature negotiation, etc, which are really common
+for all virtio devices.
+
+The transport drivers provide a set of ops (struct dm_virtio_ops) for the real
+virtio device driver to call. These ops APIs's parameter is designed to remind
+the caller to pass the correct 'struct udevice' id of the virtio device, eg:
+
+int virtio_get_status(struct udevice *vdev, u8 *status)
+
+So the parameter 'vdev' indicates the device should be the real virtio device.
+But we also have an API like:
+
+struct virtqueue *vring_create_virtqueue(unsigned int index, unsigned int num,
+ unsigned int vring_align,
+ struct udevice *udev)
+
+Here the parameter 'udev' indicates the device should be the transport device.
+Similar naming is applied in other functions that are even not APIs, eg:
+
+static int virtio_uclass_post_probe(struct udevice *udev)
+static int virtio_uclass_child_pre_probe(struct udevice *vdev)
+
+So it's easy to tell which device these functions are operating on.
+
+Development Flow
+----------------
+At present only VirtIO network card (device ID 1) and block device (device
+ID 2) are supported. If you want to develop new driver for new devices,
+please follow the guideline below.
+
+1. add new device ID in virtio.h
+#define VIRTIO_ID_XXX X
+
+2. update VIRTIO_ID_MAX_NUM to be the largest device ID plus 1
+
+3. add new driver name string in virtio.h
+#define VIRTIO_XXX_DRV_NAME "virtio-xxx"
+
+4. create a new driver with name set to the name string above
+U_BOOT_DRIVER(virtio_xxx) = {
+ .name = VIRTIO_XXX_DRV_NAME,
+ ...
+}
+
+5. provide bind() method in the driver, where virtio_driver_features_init()
+ should be called for driver to negotiate feature support with the device.
+
+6. do funny stuff with the driver
+
+References
+----------
+[1] http://docs.oasis-open.org/virtio/virtio/v1.0/virtio-v1.0.pdf
+[2] https://www.qemu.org
--
2.7.4
^ permalink raw reply related [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 01/27] dm: core: Allow uclass to set up a device's child after it is probed
2018-09-23 13:41 ` [U-Boot] [PATCH 01/27] dm: core: Allow uclass to set up a device's child after it is probed Bin Meng
@ 2018-09-27 13:41 ` Simon Glass
2018-10-11 5:14 ` Bin Meng
0 siblings, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:41 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 23 September 2018 at 06:41, Bin Meng <bmeng.cn@gmail.com> wrote:
> Some buses need to set up their child devices after they are probed.
> Support a common child_post_probe() method for the uclass.
>
> With this change, the two APIs uclass_pre_probe_device() and
> uclass_post_probe_device() become symmetric.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/core/uclass.c | 13 ++++++++++++-
> include/dm/uclass.h | 4 +++-
> 2 files changed, 15 insertions(+), 2 deletions(-)
Another option, perhaps not quite as elegant, is for the driver to
call into the uclass in its probe() method. We need to balance
elegance with the cost of adding a new field to the uclass which is
rarely used. What do you think?
Also, this does need some sort of use in sandbox, so can you update
the test driver to use it?
>
> diff --git a/drivers/core/uclass.c b/drivers/core/uclass.c
> index 3113d6a..3c7b9cf 100644
> --- a/drivers/core/uclass.c
> +++ b/drivers/core/uclass.c
> @@ -687,8 +687,19 @@ int uclass_pre_probe_device(struct udevice *dev)
>
> int uclass_post_probe_device(struct udevice *dev)
> {
> - struct uclass_driver *uc_drv = dev->uclass->uc_drv;
> + struct uclass_driver *uc_drv;
> + int ret;
> +
> + if (dev->parent) {
> + uc_drv = dev->parent->uclass->uc_drv;
> + if (uc_drv->child_post_probe) {
> + ret = uc_drv->child_post_probe(dev);
> + if (ret)
> + return ret;
> + }
> + }
>
> + uc_drv = dev->uclass->uc_drv;
> if (uc_drv->post_probe)
> return uc_drv->post_probe(dev);
>
> diff --git a/include/dm/uclass.h b/include/dm/uclass.h
> index 6e7c1cd..610c68d 100644
> --- a/include/dm/uclass.h
> +++ b/include/dm/uclass.h
> @@ -58,7 +58,8 @@ struct udevice;
> * @post_probe: Called after a new device is probed
> * @pre_remove: Called before a device is removed
> * @child_post_bind: Called after a child is bound to a device in this uclass
> - * @child_pre_probe: Called before a child is probed in this uclass
> + * @child_pre_probe: Called before a child in this uclass is probed
> + * @child_post_probe: Called after a child in this uclass is probed
> * @init: Called to set up the uclass
> * @destroy: Called to destroy the uclass
> * @priv_auto_alloc_size: If non-zero this is the size of the private data
> @@ -91,6 +92,7 @@ struct uclass_driver {
> int (*pre_remove)(struct udevice *dev);
> int (*child_post_bind)(struct udevice *dev);
> int (*child_pre_probe)(struct udevice *dev);
> + int (*child_post_probe)(struct udevice *dev);
> int (*init)(struct uclass *class);
> int (*destroy)(struct uclass *class);
> int priv_auto_alloc_size;
> --
> 2.7.4
>
Regards,
Simon
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices
2018-09-23 13:42 ` [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
2018-10-11 9:08 ` Bin Meng
2018-09-27 22:10 ` Tuomas Tynkkynen
1 sibling, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> This adds a new virtio uclass driver for “virtio” [1] family of
> devices that are are found in virtual environments like QEMU,
> yet by design they look like physical devices to the guest.
>
> The uclass driver provides child_pre_probe() and child_post_probe()
> methods to do some common operations for virtio device drivers like
> device and driver supported feature negotiation, etc.
>
> [1] http://docs.oasis-open.org/virtio/virtio/v1.0/virtio-v1.0.pdf
Can you add this link to the header file too? This seems to be lacking
docs.in the source code. Also in a header file, a short statement of
what virtio is for would be good.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/Kconfig | 2 +
> drivers/Makefile | 1 +
> drivers/virtio/Kconfig | 14 +
> drivers/virtio/Makefile | 6 +
> drivers/virtio/virtio-uclass.c | 333 ++++++++++++++++++++
> include/dm/uclass-id.h | 1 +
> include/virtio.h | 694 +++++++++++++++++++++++++++++++++++++++++
> include/virtio_types.h | 24 ++
> 8 files changed, 1075 insertions(+)
> create mode 100644 drivers/virtio/Kconfig
> create mode 100644 drivers/virtio/Makefile
> create mode 100644 drivers/virtio/virtio-uclass.c
> create mode 100644 include/virtio.h
> create mode 100644 include/virtio_types.h
>
> diff --git a/drivers/Kconfig b/drivers/Kconfig
> index 56536c4..d40db0d 100644
> --- a/drivers/Kconfig
> +++ b/drivers/Kconfig
> @@ -106,6 +106,8 @@ source "drivers/usb/Kconfig"
>
> source "drivers/video/Kconfig"
>
> +source "drivers/virtio/Kconfig"
> +
> source "drivers/watchdog/Kconfig"
>
> config PHYS_TO_BUS
> diff --git a/drivers/Makefile b/drivers/Makefile
> index 23ea609..f09daae 100644
> --- a/drivers/Makefile
> +++ b/drivers/Makefile
> @@ -14,6 +14,7 @@ obj-$(CONFIG_$(SPL_TPL_)SERIAL_SUPPORT) += serial/
> obj-$(CONFIG_$(SPL_TPL_)SPI_FLASH_SUPPORT) += mtd/spi/
> obj-$(CONFIG_$(SPL_TPL_)SPI_SUPPORT) += spi/
> obj-$(CONFIG_$(SPL_TPL_)TIMER) += timer/
> +obj-$(CONFIG_$(SPL_TPL_)VIRTIO) += virtio/
> obj-$(CONFIG_$(SPL_)DM_MAILBOX) += mailbox/
> obj-$(CONFIG_$(SPL_)REMOTEPROC) += remoteproc/
>
> diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
> new file mode 100644
> index 0000000..bdfa96a
> --- /dev/null
> +++ b/drivers/virtio/Kconfig
> @@ -0,0 +1,14 @@
> +# SPDX-License-Identifier: GPL-2.0+
> +#
> +# Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> +# Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> +
> +menu "VirtIO Drivers"
> +
> +config VIRTIO
> + bool
> + help
> + This option is selected by any driver which implements the virtio
> + bus, such as CONFIG_VIRTIO_MMIO or CONFIG_VIRTIO_PCI.
What is a virtio bus?
> +
> +endmenu
> diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
> new file mode 100644
> index 0000000..23e7be7
> --- /dev/null
> +++ b/drivers/virtio/Makefile
> @@ -0,0 +1,6 @@
> +# SPDX-License-Identifier: GPL-2.0+
> +#
> +# Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> +# Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> +
> +obj-y += virtio-uclass.o
> diff --git a/drivers/virtio/virtio-uclass.c b/drivers/virtio/virtio-uclass.c
> new file mode 100644
> index 0000000..1c85856
> --- /dev/null
> +++ b/drivers/virtio/virtio-uclass.c
> @@ -0,0 +1,333 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> + * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> + */
> +
> +#include <common.h>
> +#include <dm.h>
> +#include <virtio.h>
> +#include <dm/device.h>
> +#include <dm/lists.h>
> +
> +static const char *const virtio_drv_name[VIRTIO_ID_MAX_NUM] = {
> + [VIRTIO_ID_NET] = VIRTIO_NET_DRV_NAME,
> + [VIRTIO_ID_BLOCK] = VIRTIO_BLK_DRV_NAME,
> +};
> +
> +int virtio_get_config(struct udevice *vdev, unsigned int offset,
> + void *buf, unsigned int len)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->get_config)
> + return -ENOSYS;
blank line before return (fix globally)
> + return ops->get_config(vdev->parent, offset, buf, len);
> +}
> +
> +int virtio_set_config(struct udevice *vdev, unsigned int offset,
> + void *buf, unsigned int len)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->set_config)
> + return -ENOSYS;
> + return ops->set_config(vdev->parent, offset, buf, len);
> +}
> +
> +int virtio_generation(struct udevice *vdev, u32 *counter)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->generation)
> + return -ENOSYS;
> + return ops->generation(vdev->parent, counter);
> +}
> +
> +int virtio_get_status(struct udevice *vdev, u8 *status)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->get_status)
> + return -ENOSYS;
> + return ops->get_status(vdev->parent, status);
> +}
> +
> +int virtio_set_status(struct udevice *vdev, u8 status)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->set_status)
> + return -ENOSYS;
> + return ops->set_status(vdev->parent, status);
> +}
> +
> +int virtio_reset(struct udevice *vdev)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->reset)
> + return -ENOSYS;
> + return ops->reset(vdev->parent);
> +}
> +
> +int virtio_get_features(struct udevice *vdev, u64 *features)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->get_features)
> + return -ENOSYS;
> + return ops->get_features(vdev->parent, features);
> +}
> +
> +int virtio_set_features(struct udevice *vdev)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->set_features)
> + return -ENOSYS;
> + return ops->set_features(vdev->parent);
> +}
> +
> +int virtio_find_vqs(struct udevice *vdev, unsigned int nvqs,
> + struct virtqueue *vqs[])
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->find_vqs)
> + return -ENOSYS;
> + return ops->find_vqs(vdev->parent, nvqs, vqs);
> +}
> +
> +int virtio_del_vqs(struct udevice *vdev)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->del_vqs)
> + return -ENOSYS;
> + return ops->del_vqs(vdev->parent);
> +}
> +
> +int virtio_notify(struct udevice *vdev, struct virtqueue *vq)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->notify)
> + return -ENOSYS;
> + return ops->notify(vdev->parent, vq);
> +}
> +
> +void virtio_add_status(struct udevice *vdev, u8 status)
> +{
> + u8 old;
> +
> + if (!virtio_get_status(vdev, &old))
> + virtio_set_status(vdev, old | status);
> +}
> +
> +int virtio_finalize_features(struct udevice *vdev)
> +{
> + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
> + u8 status;
> + int ret;
> +
> + ret = virtio_set_features(vdev);
> + if (ret)
> + return ret;
> +
> + if (uc_priv->legacy)
> + return 0;
> +
> + virtio_add_status(vdev, VIRTIO_CONFIG_S_FEATURES_OK);
> + ret = virtio_get_status(vdev, &status);
> + if (ret)
> + return ret;
> + if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
> + debug("(%s): device refuses features %x\n", vdev->name, status);
> + return -ENODEV;
> + }
> +
> + return 0;
> +}
> +
> +void virtio_driver_features_init(struct virtio_dev_priv *priv,
> + u32 *feature, u32 feature_size,
> + u32 *feature_legacy, u32 feature_legacy_size)
> +{
> + priv->feature_table = feature;
> + priv->feature_table_size = feature_size;
> + priv->feature_table_legacy = feature_legacy;
> + priv->feature_table_size_legacy = feature_legacy_size;
> +}
> +
> +void virtio_init(void)
Shouldn't this return int if there is an error?
> +{
> + struct udevice *bus;
> +
> + /* Enumerate all known virtio devices */
> + for (uclass_first_device(UCLASS_VIRTIO, &bus);
> + bus;
> + uclass_next_device(&bus)) {
> + ;
> + }
> +}
> +
> +static int virtio_uclass_post_probe(struct udevice *udev)
> +{
> + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
> + char dev_name[30], *str;
> + struct udevice *vdev;
> + int ret;
> +
> + if (uc_priv->device > VIRTIO_ID_MAX_NUM) {
> + debug("(%s): virtio device ID %d exceeds maximum num\n",
> + udev->name, uc_priv->device);
> + return 0;
> + }
> +
> + if (!virtio_drv_name[uc_priv->device]) {
> + debug("(%s): underlying virtio device driver unavailable\n",
> + udev->name);
> + return 0;
> + }
> +
> + snprintf(dev_name, sizeof(dev_name), "%s#%d",
> + virtio_drv_name[uc_priv->device], udev->seq);
> + str = strdup(dev_name);
> + if (!str)
> + return -ENOMEM;
You might consider using log_ret() or log_msg_ret() for your error returns
> +
> + ret = device_bind_driver(udev, virtio_drv_name[uc_priv->device],
> + str, &vdev);
> + if (ret == -ENOENT) {
> + debug("(%s): no driver configured\n", udev->name);
> + return 0;
> + }
> + if (ret) {
> + free(str);
> + return ret;
> + }
> + device_set_name_alloced(vdev);
> +
> + return 0;
> +}
> +
> +static int virtio_uclass_child_post_bind(struct udevice *vdev)
> +{
> + /* Acknowledge that we've seen the device */
> + virtio_add_status(vdev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
Not sure this is worth having a new hook?
> +
> + return 0;
> +}
> +
> +static int virtio_uclass_child_pre_probe(struct udevice *vdev)
> +{
> + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
> + u64 device_features;
> + u64 driver_features;
> + u64 driver_features_legacy;
> + int i;
> + int ret;
> +
> + /*
> + * Save the real virtio device (eg: virtio-net, virtio-blk) to
> + * the transport (parent) device's uclass priv for future use.
> + */
> + uc_priv->vdev = vdev;
> +
> + /*
> + * We always start by resetting the device, in case a previous driver
> + * messed it up. This also tests that code path a little.
> + */
> + ret = virtio_reset(vdev);
> + if (ret)
> + goto err;
> +
> + /* We have a driver! */
> + virtio_add_status(vdev, VIRTIO_CONFIG_S_DRIVER);
> +
> + /* Figure out what features the device supports */
> + virtio_get_features(vdev, &device_features);
> + debug("(%s) plain device features supported %016llx\n",
> + vdev->name, device_features);
> + if (!(device_features & (1ULL << VIRTIO_F_VERSION_1)))
> + uc_priv->legacy = true;
> +
> + /* Figure out what features the driver supports */
> + driver_features = 0;
> + for (i = 0; i < uc_priv->feature_table_size; i++) {
> + unsigned int f = uc_priv->feature_table[i];
> +
> + WARN_ON(f >= 64);
> + driver_features |= (1ULL << f);
> + }
> +
> + /* Some drivers have a separate feature table for virtio v1.0 */
> + if (uc_priv->feature_table_legacy) {
> + driver_features_legacy = 0;
> + for (i = 0; i < uc_priv->feature_table_size_legacy; i++) {
> + unsigned int f = uc_priv->feature_table_legacy[i];
> +
> + WARN_ON(f >= 64);
> + driver_features_legacy |= (1ULL << f);
> + }
> + } else {
> + driver_features_legacy = driver_features;
> + }
> +
> + if (uc_priv->legacy) {
> + debug("(%s): legacy virtio device\n", vdev->name);
> + uc_priv->features = driver_features_legacy & device_features;
> + } else {
> + debug("(%s): v1.0 complaint virtio device\n", vdev->name);
> + uc_priv->features = driver_features & device_features;
> + }
> +
> + /* Transport features always preserved to pass to finalize_features */
> + for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)
> + if ((device_features & (1ULL << i)) &&
> + (i == VIRTIO_F_VERSION_1))
> + __virtio_set_bit(vdev->parent, i);
> +
> + debug("(%s) final negotiated features supported %016llx\n",
> + vdev->name, uc_priv->features);
> + ret = virtio_finalize_features(vdev);
> + if (ret)
> + goto err;
> +
> + return 0;
> +
> +err:
> + virtio_add_status(vdev, VIRTIO_CONFIG_S_FAILED);
> + return ret;
> +}
> +
> +static int virtio_uclass_child_post_probe(struct udevice *vdev)
> +{
> + /* Indicates that the driver is set up and ready to drive the device */
> + virtio_add_status(vdev, VIRTIO_CONFIG_S_DRIVER_OK);
> +
> + return 0;
> +}
> +
> +UCLASS_DRIVER(virtio) = {
> + .name = "virtio",
> + .id = UCLASS_VIRTIO,
> + .flags = DM_UC_FLAG_SEQ_ALIAS,
> + .post_probe = virtio_uclass_post_probe,
> + .child_post_bind = virtio_uclass_child_post_bind,
> + .child_pre_probe = virtio_uclass_child_pre_probe,
> + .child_post_probe = virtio_uclass_child_post_probe,
> + .per_device_auto_alloc_size = sizeof(struct virtio_dev_priv),
> +};
> diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h
> index 7027ea0..08b2a8f 100644
> --- a/include/dm/uclass-id.h
> +++ b/include/dm/uclass-id.h
> @@ -93,6 +93,7 @@ enum uclass_id {
> UCLASS_VIDEO_BRIDGE, /* Video bridge, e.g. DisplayPort to LVDS */
> UCLASS_VIDEO_CONSOLE, /* Text console driver for video device */
> UCLASS_WDT, /* Watchdot Timer driver */
> + UCLASS_VIRTIO, /* VirtIO transport device */
V before W :-)
>
> UCLASS_COUNT,
> UCLASS_INVALID = -1,
> diff --git a/include/virtio.h b/include/virtio.h
> new file mode 100644
> index 0000000..efbedb2
> --- /dev/null
> +++ b/include/virtio.h
> @@ -0,0 +1,694 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +/*
> + * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> + * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> + *
> + * This file is largely based on Linux kernel virtio_*.h files
> + */
> +
> +#ifndef __VIRTIO_H__
> +#define __VIRTIO_H__
> +
> +#include <virtio_types.h>
> +#include <dm/device.h>
Should be able to avoid this, just put in C file
> +
> +#define VIRTIO_ID_NET 1 /* virtio net */
> +#define VIRTIO_ID_BLOCK 2 /* virtio block */
> +#define VIRTIO_ID_MAX_NUM 3
> +
> +#define VIRTIO_NET_DRV_NAME "virtio-net"
> +#define VIRTIO_BLK_DRV_NAME "virtio-blk"
> +
> +/* Status byte for guest to report progress, and synchronize features */
> +
> +/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
> +#define VIRTIO_CONFIG_S_ACKNOWLEDGE 1
> +/* We have found a driver for the device */
> +#define VIRTIO_CONFIG_S_DRIVER 2
> +/* Driver has used its parts of the config, and is happy */
> +#define VIRTIO_CONFIG_S_DRIVER_OK 4
> +/* Driver has finished configuring features */
> +#define VIRTIO_CONFIG_S_FEATURES_OK 8
> +/* Device entered invalid state, driver must reset it */
> +#define VIRTIO_CONFIG_S_NEEDS_RESET 0x40
> +/* We've given up on this device */
> +#define VIRTIO_CONFIG_S_FAILED 0x80
> +
> +/*
> + * Virtio feature bits VIRTIO_TRANSPORT_F_START through VIRTIO_TRANSPORT_F_END
> + * are reserved for the transport being used (eg: virtio_ring, virtio_pci etc.),
> + * the rest are per-device feature bits.
> + */
> +#define VIRTIO_TRANSPORT_F_START 28
> +#define VIRTIO_TRANSPORT_F_END 38
> +
> +#ifndef VIRTIO_CONFIG_NO_LEGACY
> +/*
> + * Do we get callbacks when the ring is completely used,
> + * even if we've suppressed them?
> + */
> +#define VIRTIO_F_NOTIFY_ON_EMPTY 24
> +
> +/* Can the device handle any descriptor layout? */
> +#define VIRTIO_F_ANY_LAYOUT 27
> +#endif /* VIRTIO_CONFIG_NO_LEGACY */
> +
> +/* v1.0 compliant */
> +#define VIRTIO_F_VERSION_1 32
> +
> +/*
> + * If clear - device has the IOMMU bypass quirk feature.
> + * If set - use platform tools to detect the IOMMU.
> + *
> + * Note the reverse polarity (compared to most other features),
> + * this is for compatibility with legacy systems.
> + */
> +#define VIRTIO_F_IOMMU_PLATFORM 33
> +
> +/* Does the device support Single Root I/O Virtualization? */
> +#define VIRTIO_F_SR_IOV 37
> +
> +/**
> + * virtio scatter-gather struct
> + *
> + * @addr: sg buffer address
> + * @lengh: sg buffer length
> + */
> +struct virtio_sg {
> + void *addr;
> + size_t length;
> +};
> +
> +struct virtqueue;
> +
> +/* virtio bus operations */
> +struct dm_virtio_ops {
> + /**
> + * get_config() - read the value of a configuration field
> + *
> + * @vdev: the real virtio device
> + * @offset: the offset of the configuration field
> + * @buf: the buffer to write the field value into
> + * @len: the length of the buffer
> + * @return 0 if OK, -ve on error
> + */
> + int (*get_config)(struct udevice *vdev, unsigned int offset,
> + void *buf, unsigned int len);
> + /**
> + * set_config() - write the value of a configuration field
> + *
> + * @vdev: the real virtio device
> + * @offset: the offset of the configuration field
> + * @buf: the buffer to read the field value from
> + * @len: the length of the buffer
> + * @return 0 if OK, -ve on error
> + */
> + int (*set_config)(struct udevice *vdev, unsigned int offset,
> + const void *buf, unsigned int len);
> + /**
> + * generation() - config generation counter
> + *
> + * @vdev: the real virtio device
> + * @counter: the returned config generation counter
> + * @return 0 if OK, -ve on error
> + */
> + int (*generation)(struct udevice *vdev, u32 *counter);
> + /**
> + * get_status() - read the status byte
> + *
> + * @vdev: the real virtio device
> + * @status: the returned status byte
> + * @return 0 if OK, -ve on error
> + */
> + int (*get_status)(struct udevice *vdev, u8 *status);
> + /**
> + * set_status() - write the status byte
> + *
> + * @vdev: the real virtio device
> + * @status: the new status byte
> + * @return 0 if OK, -ve on error
> + */
> + int (*set_status)(struct udevice *vdev, u8 status);
> + /**
> + * reset() - reset the device
> + *
> + * @vdev: the real virtio device
> + * @return 0 if OK, -ve on error
> + */
> + int (*reset)(struct udevice *vdev);
> + /**
> + * get_features() - get the array of feature bits for this device
> + *
> + * @vdev: the real virtio device
> + * @features: the first 32 feature bits (all we currently need)
> + * @return 0 if OK, -ve on error
> + */
> + int (*get_features)(struct udevice *vdev, u64 *features);
> + /**
> + * set_features() - confirm what device features we'll be using
> + *
> + * @vdev: the real virtio device
> + * @return 0 if OK, -ve on error
> + */
> + int (*set_features)(struct udevice *vdev);
> + /**
> + * find_vqs() - find virtqueues and instantiate them
> + *
> + * @vdev: the real virtio device
> + * @nvqs: the number of virtqueues to find
> + * @vqs: on success, includes new virtqueues
> + * @return 0 if OK, -ve on error
> + */
> + int (*find_vqs)(struct udevice *vdev, unsigned int nvqs,
> + struct virtqueue *vqs[]);
> + /**
> + * del_vqs() - free virtqueues found by find_vqs()
> + *
> + * @vdev: the real virtio device
> + * @return 0 if OK, -ve on error
> + */
> + int (*del_vqs)(struct udevice *vdev);
> + /**
> + * notify() - notify the device to process the queue
> + *
> + * @vdev: the real virtio device
> + * @vq: virtqueue to process
> + * @return 0 if OK, -ve on error
> + */
> + int (*notify)(struct udevice *vdev, struct virtqueue *vq);
> +};
> +
> +/* Get access to a virtio bus' operations */
> +#define virtio_get_ops(dev) ((struct dm_virtio_ops *)(dev)->driver->ops)
> +
> +/**
> + * virtio uclass per device private data
> + *
> + * @vqs: virtualqueue for the virtio device
> + * @vdev: the real virtio device underneath
> + * @legacy: is it a legacy device?
> + * @device: virtio device ID
> + * @vendor: virtio vendor ID
> + * @features: negotiated supported features
> + * @feature_table: an array of feature supported by the driver
> + * @feature_table_size: number of entries in the feature table array
> + * @feature_table_legacy: same as feature_table but working in legacy mode
> + * @feature_table_size_legacy: number of entries in feature table legacy array
> + */
> +struct virtio_dev_priv {
> + struct list_head vqs;
> + struct udevice *vdev;
> + bool legacy;
> + u32 device;
> + u32 vendor;
> + u64 features;
> + u32 *feature_table;
> + u32 feature_table_size;
> + u32 *feature_table_legacy;
> + u32 feature_table_size_legacy;
> +};
> +
> +/**
> + * virtio_get_config() - read the value of a configuration field
> + *
> + * @vdev: the real virtio device
> + * @offset: the offset of the configuration field
> + * @buf: the buffer to write the field value into
> + * @len: the length of the buffer
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_get_config(struct udevice *vdev, unsigned int offset,
> + void *buf, unsigned int len);
> +
> +/**
> + * virtio_set_config() - write the value of a configuration field
> + *
> + * @vdev: the real virtio device
> + * @offset: the offset of the configuration field
> + * @buf: the buffer to read the field value from
> + * @len: the length of the buffer
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_set_config(struct udevice *vdev, unsigned int offset,
> + void *buf, unsigned int len);
> +
> +/**
> + * virtio_generation() - config generation counter
> + *
> + * @vdev: the real virtio device
> + * @counter: the returned config generation counter
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_generation(struct udevice *vdev, u32 *counter);
> +
> +/**
> + * virtio_get_status() - read the status byte
> + *
> + * @vdev: the real virtio device
> + * @status: the returned status byte
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_get_status(struct udevice *vdev, u8 *status);
> +
> +/**
> + * virtio_set_status() - write the status byte
> + *
> + * @vdev: the real virtio device
> + * @status: the new status byte
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_set_status(struct udevice *vdev, u8 status);
> +
> +/**
> + * virtio_reset() - reset the device
> + *
> + * @vdev: the real virtio device
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_reset(struct udevice *vdev);
> +
> +/**
> + * virtio_get_features() - get the array of feature bits for this device
> + *
> + * @vdev: the real virtio device
> + * @features: the first 32 feature bits (all we currently need)
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_get_features(struct udevice *vdev, u64 *features);
> +
> +/**
> + * virtio_set_features() - confirm what device features we'll be using
> + *
> + * @vdev: the real virtio device
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_set_features(struct udevice *vdev);
> +
> +/**
> + * virtio_find_vqs() - find virtqueues and instantiate them
> + *
> + * @vdev: the real virtio device
> + * @nvqs: the number of virtqueues to find
> + * @vqs: on success, includes new virtqueues
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_find_vqs(struct udevice *vdev, unsigned int nvqs,
> + struct virtqueue *vqs[]);
> +
> +/**
> + * virtio_del_vqs() - free virtqueues found by find_vqs()
> + *
> + * @vdev: the real virtio device
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_del_vqs(struct udevice *vdev);
> +
> +/**
> + * virtio_notify() - notify the device to process the queue
> + *
> + * @vdev: the real virtio device
> + * @vq: virtqueue to process
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_notify(struct udevice *vdev, struct virtqueue *vq);
> +
> +/**
> + * virtio_add_status() - helper to set a new status code to the device
> + *
> + * @vdev: the real virtio device
> + * @status: new status code to be added
> + */
> +void virtio_add_status(struct udevice *vdev, u8 status);
> +
> +/**
> + * virtio_finalize_features() - helper to finalize features
> + *
> + * @vdev: the real virtio device
> + * @return 0 if OK, -ve on error
> + */
> +int virtio_finalize_features(struct udevice *vdev);
> +
> +/**
> + * virtio_driver_features_init() - initialize driver supported features
> + *
> + * This fills in the virtio device parent per child private data with the given
> + * information, which contains driver supported features and legacy features.
> + *
> + * This API should be called in the virtio device driver's bind method, so that
> + * later virtio transport uclass driver can utilize the driver supplied features
> + * to negotiate with the device on the final supported features.
> + *
> + * @priv: virtio uclass per device private data
> + * @feature: an array of feature supported by the driver
> + * @feature_size: number of entries in the feature table array
> + * @feature_legacy: same as feature_table but working in legacy mode
> + * @feature_legacy_size:number of entries in feature table legacy array
> + */
> +void virtio_driver_features_init(struct virtio_dev_priv *priv,
> + u32 *feature, u32 feature_size,
> + u32 *feature_legacy, u32 feature_legacy_size);
> +
> +/**
> + * virtio_init() - helper to enumerate all known virtio devices
> + */
> +void virtio_init(void);
> +
> +static inline u16 __virtio16_to_cpu(bool little_endian, __virtio16 val)
> +{
> + if (little_endian)
> + return le16_to_cpu((__force __le16)val);
> + else
> + return be16_to_cpu((__force __be16)val);
> +}
> +
> +static inline __virtio16 __cpu_to_virtio16(bool little_endian, u16 val)
> +{
> + if (little_endian)
> + return (__force __virtio16)cpu_to_le16(val);
> + else
> + return (__force __virtio16)cpu_to_be16(val);
> +}
> +
> +static inline u32 __virtio32_to_cpu(bool little_endian, __virtio32 val)
> +{
> + if (little_endian)
> + return le32_to_cpu((__force __le32)val);
> + else
> + return be32_to_cpu((__force __be32)val);
> +}
> +
> +static inline __virtio32 __cpu_to_virtio32(bool little_endian, u32 val)
> +{
> + if (little_endian)
> + return (__force __virtio32)cpu_to_le32(val);
> + else
> + return (__force __virtio32)cpu_to_be32(val);
> +}
> +
> +static inline u64 __virtio64_to_cpu(bool little_endian, __virtio64 val)
> +{
> + if (little_endian)
> + return le64_to_cpu((__force __le64)val);
> + else
> + return be64_to_cpu((__force __be64)val);
> +}
> +
> +static inline __virtio64 __cpu_to_virtio64(bool little_endian, u64 val)
> +{
> + if (little_endian)
> + return (__force __virtio64)cpu_to_le64(val);
> + else
> + return (__force __virtio64)cpu_to_be64(val);
> +}
> +
> +/**
> + * __virtio_test_bit - helper to test feature bits
> + *
> + * For use by transports. Devices should normally use virtio_has_feature,
> + * which includes more checks.
> + *
> + * @udev: the transport device
> + * @fbit: the feature bit
> + */
> +static inline bool __virtio_test_bit(struct udevice *udev, unsigned int fbit)
> +{
> + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
> +
> + /* Did you forget to fix assumptions on max features? */
> + if (__builtin_constant_p(fbit))
> + BUILD_BUG_ON(fbit >= 64);
> + else
> + WARN_ON(fbit >= 64);
> +
> + return uc_priv->features & BIT_ULL(fbit);
Why is this (and the ones below) inline? I worry this might bloat the
code for no purpose?
> +}
> +
> +/**
> + * __virtio_set_bit - helper to set feature bits
> + *
> + * For use by transports.
> + *
> + * @udev: the transport device
> + * @fbit: the feature bit
> + */
> +static inline void __virtio_set_bit(struct udevice *udev, unsigned int fbit)
> +{
> + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
> +
> + /* Did you forget to fix assumptions on max features? */
> + if (__builtin_constant_p(fbit))
> + BUILD_BUG_ON(fbit >= 64);
> + else
> + WARN_ON(fbit >= 64);
> +
> + uc_priv->features |= BIT_ULL(fbit);
> +}
> +
> +/**
> + * __virtio_clear_bit - helper to clear feature bits
> + *
> + * For use by transports.
> + *
> + * @vdev: the transport device
> + * @fbit: the feature bit
> + */
> +static inline void __virtio_clear_bit(struct udevice *udev, unsigned int fbit)
> +{
> + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
> +
> + /* Did you forget to fix assumptions on max features? */
> + if (__builtin_constant_p(fbit))
> + BUILD_BUG_ON(fbit >= 64);
> + else
> + WARN_ON(fbit >= 64);
> +
> + uc_priv->features &= ~BIT_ULL(fbit);
> +}
> +
> +/**
> + * virtio_has_feature - helper to determine if this device has this feature
> + *
> + * Note this API is only usable after the virtio device driver's bind phase,
> + * as the feature has been negotiated between the device and the driver.
> + *
> + * @vdev: the virtio device
> + * @fbit: the feature bit
> + */
> +static inline bool virtio_has_feature(struct udevice *vdev, unsigned int fbit)
> +{
> + if (!(vdev->flags & DM_FLAG_BOUND))
> + WARN_ON(true);
> +
> + return __virtio_test_bit(vdev->parent, fbit);
> +}
> +
> +static inline bool virtio_legacy_is_little_endian(void)
> +{
> +#ifdef __LITTLE_ENDIAN
> + return true;
> +#else
> + return false;
> +#endif
> +}
> +
> +static inline bool virtio_is_little_endian(struct udevice *vdev)
> +{
> + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
> +
> + return !uc_priv->legacy || virtio_legacy_is_little_endian();
> +}
> +
> +/* Memory accessors */
> +static inline u16 virtio16_to_cpu(struct udevice *vdev, __virtio16 val)
> +{
> + return __virtio16_to_cpu(virtio_is_little_endian(vdev), val);
> +}
> +
> +static inline __virtio16 cpu_to_virtio16(struct udevice *vdev, u16 val)
> +{
> + return __cpu_to_virtio16(virtio_is_little_endian(vdev), val);
> +}
> +
> +static inline u32 virtio32_to_cpu(struct udevice *vdev, __virtio32 val)
> +{
> + return __virtio32_to_cpu(virtio_is_little_endian(vdev), val);
> +}
> +
> +static inline __virtio32 cpu_to_virtio32(struct udevice *vdev, u32 val)
> +{
> + return __cpu_to_virtio32(virtio_is_little_endian(vdev), val);
> +}
> +
> +static inline u64 virtio64_to_cpu(struct udevice *vdev, __virtio64 val)
> +{
> + return __virtio64_to_cpu(virtio_is_little_endian(vdev), val);
> +}
> +
> +static inline __virtio64 cpu_to_virtio64(struct udevice *vdev, u64 val)
> +{
> + return __cpu_to_virtio64(virtio_is_little_endian(vdev), val);
> +}
> +
> +/* Read @count fields, @bytes each */
> +static inline void __virtio_cread_many(struct udevice *vdev,
> + unsigned int offset,
> + void *buf, size_t count, size_t bytes)
> +{
> + u32 old, gen;
> + int i;
> +
> + virtio_generation(vdev, &gen);
Error check?
Should be in the uclass C file I think
> + do {
> + old = gen;
> +
> + for (i = 0; i < count; i++)
> + virtio_get_config(vdev, offset + bytes * i,
> + buf + i * bytes, bytes);
> +
> + virtio_generation(vdev, &gen);
> + } while (gen != old);
> +}
> +
> +static inline void virtio_cread_bytes(struct udevice *vdev,
> + unsigned int offset,
> + void *buf, size_t len)
> +{
> + __virtio_cread_many(vdev, offset, buf, len, 1);
> +}
> +
> +static inline u8 virtio_cread8(struct udevice *vdev, unsigned int offset)
> +{
> + u8 ret;
> +
> + virtio_get_config(vdev, offset, &ret, sizeof(ret));
> + return ret;
> +}
> +
> +static inline void virtio_cwrite8(struct udevice *vdev,
> + unsigned int offset, u8 val)
> +{
> + virtio_set_config(vdev, offset, &val, sizeof(val));
> +}
> +
> +static inline u16 virtio_cread16(struct udevice *vdev,
> + unsigned int offset)
> +{
> + u16 ret;
> +
> + virtio_get_config(vdev, offset, &ret, sizeof(ret));
> + return virtio16_to_cpu(vdev, (__force __virtio16)ret);
> +}
> +
> +static inline void virtio_cwrite16(struct udevice *vdev,
> + unsigned int offset, u16 val)
> +{
> + val = (__force u16)cpu_to_virtio16(vdev, val);
> + virtio_set_config(vdev, offset, &val, sizeof(val));
> +}
> +
> +static inline u32 virtio_cread32(struct udevice *vdev,
> + unsigned int offset)
> +{
> + u32 ret;
> +
> + virtio_get_config(vdev, offset, &ret, sizeof(ret));
> + return virtio32_to_cpu(vdev, (__force __virtio32)ret);
> +}
> +
> +static inline void virtio_cwrite32(struct udevice *vdev,
> + unsigned int offset, u32 val)
> +{
> + val = (__force u32)cpu_to_virtio32(vdev, val);
> + virtio_set_config(vdev, offset, &val, sizeof(val));
> +}
> +
> +static inline u64 virtio_cread64(struct udevice *vdev,
> + unsigned int offset)
> +{
> + u64 ret;
> +
> + __virtio_cread_many(vdev, offset, &ret, 1, sizeof(ret));
> + return virtio64_to_cpu(vdev, (__force __virtio64)ret);
> +}
> +
> +static inline void virtio_cwrite64(struct udevice *vdev,
> + unsigned int offset, u64 val)
> +{
> + val = (__force u64)cpu_to_virtio64(vdev, val);
> + virtio_set_config(vdev, offset, &val, sizeof(val));
> +}
> +
> +/* Config space read accessor */
> +#define virtio_cread(vdev, structname, member, ptr) \
> + do { \
> + /* Must match the member's type, and be integer */ \
> + if (!typecheck(typeof((((structname *)0)->member)), *(ptr))) \
> + (*ptr) = 1; \
> + \
> + switch (sizeof(*ptr)) { \
> + case 1: \
> + *(ptr) = virtio_cread8(vdev, \
> + offsetof(structname, member)); \
> + break; \
> + case 2: \
> + *(ptr) = virtio_cread16(vdev, \
> + offsetof(structname, member)); \
> + break; \
> + case 4: \
> + *(ptr) = virtio_cread32(vdev, \
> + offsetof(structname, member)); \
> + break; \
> + case 8: \
> + *(ptr) = virtio_cread64(vdev, \
> + offsetof(structname, member)); \
> + break; \
> + default: \
> + WARN_ON(true); \
> + } \
> + } while (0)
> +
> +/* Config space write accessor */
> +#define virtio_cwrite(vdev, structname, member, ptr) \
> + do { \
> + /* Must match the member's type, and be integer */ \
> + if (!typecheck(typeof((((structname *)0)->member)), *(ptr))) \
> + WARN_ON((*ptr) == 1); \
> + \
> + switch (sizeof(*ptr)) { \
> + case 1: \
> + virtio_cwrite8(vdev, \
> + offsetof(structname, member), \
> + *(ptr)); \
> + break; \
> + case 2: \
> + virtio_cwrite16(vdev, \
> + offsetof(structname, member), \
> + *(ptr)); \
> + break; \
> + case 4: \
> + virtio_cwrite32(vdev, \
> + offsetof(structname, member), \
> + *(ptr)); \
> + break; \
> + case 8: \
> + virtio_cwrite64(vdev, \
> + offsetof(structname, member), \
> + *(ptr)); \
> + break; \
> + default: \
> + WARN_ON(true); \
> + } \
> + } while (0)
> +
> +/* Conditional config space accessors */
> +#define virtio_cread_feature(vdev, fbit, structname, member, ptr) \
> + ({ \
> + int _r = 0; \
> + if (!virtio_has_feature(vdev, fbit)) \
> + _r = -ENOENT; \
> + else \
> + virtio_cread(vdev, structname, member, ptr); \
> + _r; \
> + })
> +
> +#endif /* __VIRTIO_H__ */
> diff --git a/include/virtio_types.h b/include/virtio_types.h
> new file mode 100644
> index 0000000..d700d19
> --- /dev/null
> +++ b/include/virtio_types.h
> @@ -0,0 +1,24 @@
> +/* SPDX-License-Identifier: BSD-3-Clause */
> +/*
> + * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> + * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> + *
> + * From Linux kernel include/uapi/linux/virtio_types.h
> + */
> +
> +#ifndef _LINUX_VIRTIO_TYPES_H
> +#define _LINUX_VIRTIO_TYPES_H
> +
> +#include <linux/types.h>
> +
> +/*
> + * __virtio{16,32,64} have the following meaning:
> + * - __u{16,32,64} for virtio devices in legacy mode, accessed in native endian
> + * - __le{16,32,64} for standard-compliant virtio devices
> + */
> +
> +typedef __u16 __bitwise __virtio16;
> +typedef __u32 __bitwise __virtio32;
> +typedef __u64 __bitwise __virtio64;
> +
> +#endif /* _LINUX_VIRTIO_TYPES_H */
> --
> 2.7.4
>
Regards,
Simon
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management
2018-09-23 13:42 ` [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
2018-10-11 9:50 ` Bin Meng
2018-09-27 22:11 ` Tuomas Tynkkynen
1 sibling, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>
> This adds support for managing virtual queue/ring, the channel
> for high performance I/O between host and guest.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/virtio/Makefile | 2 +-
> drivers/virtio/virtio_ring.c | 356 +++++++++++++++++++++++++++++++++++++++++++
> include/virtio_ring.h | 320 ++++++++++++++++++++++++++++++++++++++
> 3 files changed, 677 insertions(+), 1 deletion(-)
> create mode 100644 drivers/virtio/virtio_ring.c
> create mode 100644 include/virtio_ring.h
Seems like vring_create_virtqueue() should return an error code rather
than a pointer?
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 04/27] virtio: Add virtio over mmio transport driver
2018-09-23 13:42 ` [U-Boot] [PATCH 04/27] virtio: Add virtio over mmio transport driver Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> VirtIO can use various different buses and virtio devices are
> commonly implemented as PCI devices. But virtual environments
> without PCI support (a common situation in embedded devices
> models) might use simple memory mapped device (“virtio-mmio”)
> instead of the PCI device.
>
> This adds a transport driver that implements UCLASS_VIRTIO for
> virtio over mmio.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/virtio/Kconfig | 7 +
> drivers/virtio/Makefile | 1 +
> drivers/virtio/virtio_mmio.c | 413 +++++++++++++++++++++++++++++++++++++++++++
> drivers/virtio/virtio_mmio.h | 129 ++++++++++++++
> 4 files changed, 550 insertions(+)
> create mode 100644 drivers/virtio/virtio_mmio.c
> create mode 100644 drivers/virtio/virtio_mmio.h
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 05/27] virtio: Add net driver support
2018-09-23 13:42 ` [U-Boot] [PATCH 05/27] virtio: Add net driver support Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
2018-09-27 22:12 ` Tuomas Tynkkynen
2018-10-22 23:09 ` Joe Hershberger
2 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>
> This adds virtio net device driver support.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/virtio/Kconfig | 7 ++
> drivers/virtio/Makefile | 1 +
> drivers/virtio/virtio_net.c | 215 +++++++++++++++++++++++++++++++++++
> drivers/virtio/virtio_net.h | 268 ++++++++++++++++++++++++++++++++++++++++++++
> 4 files changed, 491 insertions(+)
> create mode 100644 drivers/virtio/virtio_net.c
> create mode 100644 drivers/virtio/virtio_net.h
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 06/27] test: dm: blk: Correct blk_base test case
2018-09-23 13:42 ` [U-Boot] [PATCH 06/27] test: dm: blk: Correct blk_base test case Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> The blk_base test case creates a USB mass storage block device with
> the Sandbox host block device as its parent. This does not make any
> sense and causes potential issue, for example if the test case tries
> to read/write anything on the USB mass storage block device it will
> definitely fail as its parent is not on USB bus at all.
>
> Correct the test case by creating another Sandbox host block device
> instead of the USB mass storage one and adjust the case accordingly.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> test/dm/blk.c | 27 +++++++++++----------------
> 1 file changed, 11 insertions(+), 16 deletions(-)
>
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 07/27] sandbox: blk: Switch to use platdata_auto_alloc_size for the driver data
2018-09-23 13:42 ` [U-Boot] [PATCH 07/27] sandbox: blk: Switch to use platdata_auto_alloc_size for the driver data Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> Currently the sandbox block driver uses priv_auto_alloc_size for
> the driver data, however that's only available after the device
> probe phase. In order to make it accessible in an earlier phase,
> switch to use platdata_auto_alloc_size instead.
>
> This patch is the prerequisite for the follow up patch of DM BLK
> driver changes to work with Sandbox.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/block/sandbox.c | 15 ++++++++-------
> 1 file changed, 8 insertions(+), 7 deletions(-)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 08/27] efi_driver: blk: Switch to use platdata_auto_alloc_size for the driver data
2018-09-23 13:42 ` [U-Boot] [PATCH 08/27] efi_driver: " Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> Currently the efi block driver uses priv_auto_alloc_size for the
> driver data, however that's only available after the device probe
> phase. In order to make it accessible in an earlier phase, switch
> to use platdata_auto_alloc_size instead.
>
> This patch is the prerequisite for the follow up patch of DM BLK
> driver changes to work with EFI loader.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> lib/efi_driver/efi_block_device.c | 24 ++++++++++++------------
> 1 file changed, 12 insertions(+), 12 deletions(-)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 09/27] blk: Call part_init() in the post_probe() method
2018-09-23 13:42 ` [U-Boot] [PATCH 09/27] blk: Call part_init() in the post_probe() method Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> part_init() is currently called in every DM BLK driver, either
> in its bind() or probe() method. However we can use the BLK
> uclass driver's post_probe() method to do it automatically.
>
> Update all DM BLK drivers to adopt this change.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> cmd/sata.c | 9 ---------
> common/usb_storage.c | 4 +---
> drivers/block/blk-uclass.c | 12 ++++++++++++
> drivers/block/ide.c | 2 --
> drivers/block/sandbox.c | 2 +-
> drivers/mmc/mmc.c | 3 ---
> drivers/nvme/nvme.c | 1 -
> drivers/scsi/scsi.c | 1 -
> lib/efi_driver/efi_block_device.c | 2 --
> 9 files changed, 14 insertions(+), 22 deletions(-)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 10/27] blk: Drop blk_prepare_device()
2018-09-23 13:42 ` [U-Boot] [PATCH 10/27] blk: Drop blk_prepare_device() Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> With the post_probe() changes, this API is no longer needed.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/block/blk-uclass.c | 9 ---------
> include/blk.h | 10 ----------
> 2 files changed, 19 deletions(-)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 11/27] blk: Make blk_next_free_devnum() public
2018-09-23 13:42 ` [U-Boot] [PATCH 11/27] blk: Make blk_next_free_devnum() public Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> blk_next_free_devnum() can be helpful in some cases. Make it
> a public API.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/block/blk-uclass.c | 2 +-
> include/blk.h | 11 +++++++++++
> 2 files changed, 12 insertions(+), 1 deletion(-)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 12/27] blk: Introduce IF_TYPE_VIRTIO
2018-09-23 13:42 ` [U-Boot] [PATCH 12/27] blk: Introduce IF_TYPE_VIRTIO Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>
> This adds a new block interface type for VirtIO block devices.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> disk/part.c | 6 ++++++
> drivers/block/blk-uclass.c | 2 ++
> include/blk.h | 1 +
> 3 files changed, 9 insertions(+)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 13/27] virtio: Add block driver support
2018-09-23 13:42 ` [U-Boot] [PATCH 13/27] virtio: Add block driver support Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
2018-09-27 22:12 ` Tuomas Tynkkynen
0 siblings, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>
> This adds virtio block device driver support.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/virtio/Kconfig | 7 +++
> drivers/virtio/Makefile | 1 +
> drivers/virtio/virtio_blk.c | 127 +++++++++++++++++++++++++++++++++++++++++++
> drivers/virtio/virtio_blk.h | 129 ++++++++++++++++++++++++++++++++++++++++++++
> 4 files changed, 264 insertions(+)
> create mode 100644 drivers/virtio/virtio_blk.c
> create mode 100644 drivers/virtio/virtio_blk.h
Reviewed-by: Simon Glass <sjg@chromium.org>
Why does this use __u32 instead of u32?
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 14/27] virtio: cmd: Add virtio command for virtio block devices
2018-09-23 13:42 ` [U-Boot] [PATCH 14/27] virtio: cmd: Add virtio command for virtio block devices Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>
> Add 'virtio' command in U-Boot command line.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> cmd/Kconfig | 7 +++++++
> cmd/Makefile | 1 +
> cmd/virtio.c | 37 +++++++++++++++++++++++++++++++++++++
> 3 files changed, 45 insertions(+)
> create mode 100644 cmd/virtio.c
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 15/27] arm: qemu: Add a Kconfig in the board directory
2018-09-23 13:42 ` [U-Boot] [PATCH 15/27] arm: qemu: Add a Kconfig in the board directory Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> This adds a Kconfig file in the board directory, so that some
> board-specific options can be specified there.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> arch/arm/Kconfig | 1 +
> board/emulation/qemu-arm/Kconfig | 9 +++++++++
> configs/qemu_arm64_defconfig | 1 -
> configs/qemu_arm_defconfig | 1 -
> 4 files changed, 10 insertions(+), 2 deletions(-)
> create mode 100644 board/emulation/qemu-arm/Kconfig
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot
2018-09-23 13:42 ` [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
2018-10-11 13:21 ` Bin Meng
2018-09-27 22:13 ` Tuomas Tynkkynen
1 sibling, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> Currently devices on the virtio bus is not automatically enumerated,
> which means peripherals on the virtio bus are not discovered by their
> drivers. This uses board_init() to do the virtio enumeration.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> board/emulation/qemu-arm/Kconfig | 3 +++
> board/emulation/qemu-arm/qemu-arm.c | 7 +++++++
> 2 files changed, 10 insertions(+)
>
Reviewed-by: Simon Glass <sjg@chromium.org>
But I wonder if we should have a flag in the uclass or perhaps device
tree, to indicate that all devices in it should be probed at start-up?
Could be useful for PCI too.
> diff --git a/board/emulation/qemu-arm/Kconfig b/board/emulation/qemu-arm/Kconfig
> index d1c08c2..16b80fe 100644
> --- a/board/emulation/qemu-arm/Kconfig
> +++ b/board/emulation/qemu-arm/Kconfig
> @@ -5,5 +5,8 @@ config SYS_TEXT_BASE
>
> config BOARD_SPECIFIC_OPTIONS # dummy
> def_bool y
> + imply VIRTIO_MMIO
> + imply VIRTIO_NET
> + imply VIRTIO_BLK
>
> endif
> diff --git a/board/emulation/qemu-arm/qemu-arm.c b/board/emulation/qemu-arm/qemu-arm.c
> index 812c906..428498e 100644
> --- a/board/emulation/qemu-arm/qemu-arm.c
> +++ b/board/emulation/qemu-arm/qemu-arm.c
> @@ -4,6 +4,7 @@
> */
> #include <common.h>
> #include <fdtdec.h>
> +#include <virtio.h>
>
> #ifdef CONFIG_ARM64
> #include <asm/armv8/mmu.h>
> @@ -58,6 +59,12 @@ struct mm_region *mem_map = qemu_arm64_mem_map;
>
> int board_init(void)
> {
> + /*
> + * Make sure virtio bus is enumerated so that peripherals
> + * on the virtio bus can be discovered by their drivers
> + */
> + virtio_init();
> +
> return 0;
> }
>
> --
> 2.7.4
>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 17/27] riscv: qemu: Enumerate virtio bus during early boot
2018-09-23 13:42 ` [U-Boot] [PATCH 17/27] riscv: " Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> Currently devices on the virtio bus is not automatically enumerated,
> which means peripherals on the virtio bus are not discovered by their
> drivers. This uses board_init() to do the virtio enumeration.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> board/emulation/qemu-riscv/Kconfig | 3 +++
> board/emulation/qemu-riscv/qemu-riscv.c | 7 +++++++
> 2 files changed, 10 insertions(+)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 18/27] riscv: qemu: Include some useful commands
2018-09-23 13:42 ` [U-Boot] [PATCH 18/27] riscv: qemu: Include some useful commands Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
2018-09-27 22:14 ` Tuomas Tynkkynen
1 sibling, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> With the virtio net and blk drivers, we can do more stuff with some
> useful commands. Imply those in the board Kconfig.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> board/emulation/qemu-riscv/Kconfig | 8 ++++++++
> 1 file changed, 8 insertions(+)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 19/27] kconfig: Introduce HAVE_ARCH_IOMAP
2018-09-23 13:42 ` [U-Boot] [PATCH 19/27] kconfig: Introduce HAVE_ARCH_IOMAP Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> Introduce a new Kconfig option for architecture codes to control
> whether it provides io{read,write}{8,16,32} I/O accessor functions.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> include/linux/io.h | 4 ++++
> lib/Kconfig | 6 ++++++
> 2 files changed, 10 insertions(+)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 20/27] x86: Implement arch-specific io accessor routines
2018-09-23 13:42 ` [U-Boot] [PATCH 20/27] x86: Implement arch-specific io accessor routines Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
2018-10-11 13:33 ` Bin Meng
0 siblings, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> At present the generic io{read,write}{8,16,32} routines only support
> MMIO access. With architecture like x86 that has a separate IO space,
> these routines cannot be used to access I/O ports.
>
> Implement x86-specific version to support both PIO and MMIO access,
> so that drivers for multiple architectures can use these accessors
> without the need to know whether it's MMIO or PIO.
>
> These are ported from Linux kernel lib/iomap.c, with slight changes.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> arch/Kconfig | 1 +
> arch/x86/include/asm/io.h | 66 +++++++++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 67 insertions(+)
Reviewed-by: Simon Glass <sjg@chromium.org>
Should we use regmap instead?
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 21/27] virtio: Add virtio over pci transport driver
2018-09-23 13:42 ` [U-Boot] [PATCH 21/27] virtio: Add virtio over pci transport driver Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
2018-10-11 13:39 ` Bin Meng
0 siblings, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> This adds a transport driver that implements UCLASS_VIRTIO for
> virtio over pci, which is commonly used on x86.
>
> It only supports the legacy interface of the pci transport, which
> is the default device that QEMU emulates.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/virtio/Kconfig | 8 +
> drivers/virtio/Makefile | 1 +
> drivers/virtio/virtio_pci.c | 420 ++++++++++++++++++++++++++++++++++++++++++++
> drivers/virtio/virtio_pci.h | 173 ++++++++++++++++++
> 4 files changed, 602 insertions(+)
> create mode 100644 drivers/virtio/virtio_pci.c
> create mode 100644 drivers/virtio/virtio_pci.h
Reviewed-by: Simon Glass <sjg@chromium.org>
vring_create_virtqueue() should return an error I think - you assume -ENOMEM
That is a huge table of PCI devices. Can you use a class instead?
Regards,
Simon
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 22/27] x86: qemu: Imply virtio PCI transport and device drivers
2018-09-23 13:42 ` [U-Boot] [PATCH 22/27] x86: qemu: Imply virtio PCI transport and device drivers Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> Add virtio drivers for QEMU x86 targets.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> board/emulation/qemu-x86/Kconfig | 3 +++
> 1 file changed, 3 insertions(+)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 24/27] test: dm: pci: Add cases for finding next PCI capability APIs
2018-09-23 13:42 ` [U-Boot] [PATCH 24/27] test: dm: pci: Add cases for finding next PCI capability APIs Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> Add test cases to cover the two newly added PCI APIs:
> dm_pci_find_next_capability() & dm_pci_find_next_ext_capability().
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> test/dm/pci.c | 20 ++++++++++++++++++++
> 1 file changed, 20 insertions(+)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 23/27] dm: pci: Add APIs to find next capability and extended capability
2018-09-23 13:42 ` [U-Boot] [PATCH 23/27] dm: pci: Add APIs to find next capability and extended capability Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> This introduces two new APIs dm_pci_find_next_capability() and
> dm_pci_find_next_ext_capability() to get PCI capability address
> and PCI express extended capability address for a given PCI device
> starting from a given offset.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/pci/pci-uclass.c | 48 ++++++++++++++++++++++++++++++++----------------
> include/pci.h | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 80 insertions(+), 16 deletions(-)
Are these called somewhere from sandbox?...ah yes, next patch
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 25/27] virtio: pci: Support non-legacy PCI transport device
2018-09-23 13:42 ` [U-Boot] [PATCH 25/27] virtio: pci: Support non-legacy PCI transport device Bin Meng
@ 2018-09-27 13:42 ` Simon Glass
2018-10-11 13:41 ` Bin Meng
0 siblings, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:42 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> By default QEMU creates legacy PCI transport devices, but we can
> ask QEMU to create non-legacy one if we pass additional device
> property/value pairs in the command line:
>
> -device virtio-blk-pci,disable-legacy=true,disable-modern=false
>
> This adds a new driver driver to support non-legacy (modern) device
> mode. Previous driver/file name is changed accordingly.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/virtio/Makefile | 2 +-
> .../virtio/{virtio_pci.c => virtio_pci_legacy.c} | 6 +-
> drivers/virtio/virtio_pci_modern.c | 612 +++++++++++++++++++++
> 3 files changed, 616 insertions(+), 4 deletions(-)
> rename drivers/virtio/{virtio_pci.c => virtio_pci_legacy.c} (98%)
> create mode 100644 drivers/virtio/virtio_pci_modern.c
Reviewed-by: Simon Glass <sjg@chromium.org>
Isn't there some common code between the two?
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 26/27] virtio: net: Support non-legacy device
2018-09-23 13:42 ` [U-Boot] [PATCH 26/27] virtio: net: Support non-legacy device Bin Meng
@ 2018-09-27 13:43 ` Simon Glass
2018-10-15 21:59 ` Joe Hershberger
1 sibling, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:43 UTC (permalink / raw)
To: u-boot
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> For v1.0 compliant device, it always assumes the member 'num_buffers'
> exists in the struct virtio_net_hdr while the legacy driver only
> presented 'num_buffers' when VIRTIO_NET_F_MRG_RXBUF was negotiated.
> Without that feature the structure was 2 bytes shorter.
>
> Update the driver to support the non-legacy device.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/virtio/virtio_net.c | 31 ++++++++++++++++++++++++++-----
> 1 file changed, 26 insertions(+), 5 deletions(-)
Reviewed-by: Simon Glass <sjg@chromium.org>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 27/27] doc: Document virtio support
2018-09-23 13:42 ` [U-Boot] [PATCH 27/27] doc: Document virtio support Bin Meng
@ 2018-09-27 13:43 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:43 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> Add REAME.virtio to describe the information about U-Boot support for
> VirtIO devices, including supported boards, build instructions, driver
> details etc.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
>
> ---
>
> doc/README.virtio | 247 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 247 insertions(+)
> create mode 100644 doc/README.virtio
Reviewed-by: Simon Glass <sjg@chromium.org>
Great docs!
- Simon
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
` (26 preceding siblings ...)
2018-09-23 13:42 ` [U-Boot] [PATCH 27/27] doc: Document virtio support Bin Meng
@ 2018-09-27 13:43 ` Simon Glass
2018-09-27 22:19 ` Tuomas Tynkkynen
27 siblings, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-09-27 13:43 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 23 September 2018 at 06:41, Bin Meng <bmeng.cn@gmail.com> wrote:
> This series brings in VirtIO driver support in U-Boot. The work is based
> on Tuomas's virtio support on QEMU ARM targets.
>
> VirtIO is a virtualization standard for network and disk device drivers
> where just the guest's device driver "knows" it is running in a virtual
> environment, and cooperates with the hypervisor. This enables guests to
> get high performance network and disk operations, and gives most of the
> performance benefits of paravirtualization. In the U-Boot case, the
> guest is U-Boot itself, while the virtual environment are normally QEMU
> targets like ARM, RISC-V and x86.
>
> Both VirtIO MMIO and PCI transport options are supported. Only VirtIO
> network and block device drivers are supported for now.
>
> The following QEMU targets are supported.
>
> - qemu_arm_defconfig
> - qemu_arm64_defconfig
> - qemu-riscv32_defconfig
> - qemu-riscv64_defconfig
> - qemu-x86_defconfig
> - qemu-x86_64_defconfig
>
> A new child_post_probe() uclass driver method is introduced to better
> support virtio device driver. This also changes BLK uclass driver to
> supply a post_probe() method which calls part_init(), so that we can
> avoid duplicating such call in every BLK driver.
>
> Not every checkpatch warning reported was fixed, but I tried to fix as
> many as possible which makes sense.
>
> This series needs to be applied after the risc-v QEMU series is applied.
>
> This series is available at u-boot-x86/virtio-working for testing.
> Note the branch already contains the risc-v QEMU series plus one network
> stack fix to make virtio-net driver happy.
>
Looks like a very nice implementation.
How does this all get tested? Could we have a simple sandbox driver?
Regards,
Simon
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices
2018-09-23 13:42 ` [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices Bin Meng
2018-09-27 13:42 ` Simon Glass
@ 2018-09-27 22:10 ` Tuomas Tynkkynen
2018-10-11 9:09 ` Bin Meng
1 sibling, 1 reply; 82+ messages in thread
From: Tuomas Tynkkynen @ 2018-09-27 22:10 UTC (permalink / raw)
To: u-boot
Hi Bin,
Thanks for the patches, they look great. Some minor comments:
On 09/23/2018 04:42 PM, Bin Meng wrote:
> This adds a new virtio uclass driver for “virtio” [1] family of
> devices that are are found in virtual environments like QEMU,
> yet by design they look like physical devices to the guest.
>
> The uclass driver provides child_pre_probe() and child_post_probe()
> methods to do some common operations for virtio device drivers like
> device and driver supported feature negotiation, etc.
>
> [1] http://docs.oasis-open.org/virtio/virtio/v1.0/virtio-v1.0.pdf
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---...
>+
>+config VIRTIO
>+ bool
>+ help
>+ This option is selected by any driver which implements the virtio
>+ bus, such as CONFIG_VIRTIO_MMIO or CONFIG_VIRTIO_PCI.
I think most other places use the term 'transport' over 'bus'.
> +
> +int virtio_get_config(struct udevice *vdev, unsigned int offset,
> + void *buf, unsigned int len)
> +{
> + struct dm_virtio_ops *ops;
> +
> + ops = virtio_get_ops(vdev->parent);
> + if (!ops->get_config)
> + return -ENOSYS;
I'm not sure how useful the -ENOSYS fallbacks for most of these ops
are. E.g. a transport lacking .find_vqs() cannot ever be useful
for implementing real-world devices.
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management
2018-09-23 13:42 ` [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management Bin Meng
2018-09-27 13:42 ` Simon Glass
@ 2018-09-27 22:11 ` Tuomas Tynkkynen
2018-10-02 15:46 ` Bin Meng
1 sibling, 1 reply; 82+ messages in thread
From: Tuomas Tynkkynen @ 2018-09-27 22:11 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 09/23/2018 04:42 PM, Bin Meng wrote:
> From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>
> This adds support for managing virtual queue/ring, the channel
> for high performance I/O between host and guest.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
...
> +
> +/*
> + * Barriers in virtio are tricky. Since we are not in a hyperviosr/guest
> + * scenario, having these as nops is enough to work as expected.
> + */
> +
> +static inline void virtio_mb(void)
> +{
> +}
> +
> +static inline void virtio_rmb(void)
> +{
> +}
> +
> +static inline void virtio_wmb(void)
> +{
> +}
> +
> +static inline void virtio_store_mb(__virtio16 *p, __virtio16 v)
> +{
> + WRITE_ONCE(*p, v);
> +}
> +
> +#endif /* _LINUX_VIRTIO_RING_H */
>
I am not convinced it's safe to leave these barriers empty. For instance
if KVM acceleration is used, I believe U-Boot could be running on one
core concurrently with QEMU's IO thread running on a different core.
Thus we need memory barriers on both sides so that updates to the
vring are observed in the correct order.
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 05/27] virtio: Add net driver support
2018-09-23 13:42 ` [U-Boot] [PATCH 05/27] virtio: Add net driver support Bin Meng
2018-09-27 13:42 ` Simon Glass
@ 2018-09-27 22:12 ` Tuomas Tynkkynen
2018-10-02 16:10 ` Bin Meng
2018-10-22 23:09 ` Joe Hershberger
2 siblings, 1 reply; 82+ messages in thread
From: Tuomas Tynkkynen @ 2018-09-27 22:12 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 09/23/2018 04:42 PM, Bin Meng wrote:
> From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>
> This adds virtio net device driver support.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
...
> +static u32 feature[] = {
> + VIRTIO_NET_F_MAC
> +};
> +
> +static u32 feature_legacy[] = {
> + VIRTIO_NET_F_MAC
> +};
These can be const.
...
> +
> +static void virtio_net_stop(struct udevice *dev)
> +{
> + /*
> + * There is no way to stop the queue from running, unless we issue
> + * a reset to the virtio device, and re-do the queue initialization
> + * from the beginning.
> + */
> +}
Unless I missed it, we still need to do something when we pass control to
Linux so that the memory used for receive buffers doesn't get overwritten
by the virtio device during Linux boot.
I think this can be done by calling virtio_reset() on the device in some
uclass-level hook, maybe .child_post_remove().
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 13/27] virtio: Add block driver support
2018-09-27 13:42 ` Simon Glass
@ 2018-09-27 22:12 ` Tuomas Tynkkynen
0 siblings, 0 replies; 82+ messages in thread
From: Tuomas Tynkkynen @ 2018-09-27 22:12 UTC (permalink / raw)
To: u-boot
Hi Simon,
On 09/27/2018 04:42 PM, Simon Glass wrote:
> On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
>> From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>>
>> This adds virtio block device driver support.
>>
>> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
>> ---
...
>
> Why does this use __u32 instead of u32?
>
The header comes from include/uapi from Linux where the underscored
forms are the convention/rule.
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot
2018-09-23 13:42 ` [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot Bin Meng
2018-09-27 13:42 ` Simon Glass
@ 2018-09-27 22:13 ` Tuomas Tynkkynen
2018-10-11 13:28 ` Bin Meng
1 sibling, 1 reply; 82+ messages in thread
From: Tuomas Tynkkynen @ 2018-09-27 22:13 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 09/23/2018 04:42 PM, Bin Meng wrote:
> Currently devices on the virtio bus is not automatically enumerated,
> which means peripherals on the virtio bus are not discovered by their
> drivers. This uses board_init() to do the virtio enumeration.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> board/emulation/qemu-arm/Kconfig | 3 +++
> board/emulation/qemu-arm/qemu-arm.c | 7 +++++++
> 2 files changed, 10 insertions(+)
>
...
>diff --git a/board/emulation/qemu-arm/Kconfig b/board/emulation/qemu-arm/Kconfig
>index d1c08c2..16b80fe 100644
>--- a/board/emulation/qemu-arm/Kconfig
>+++ b/board/emulation/qemu-arm/Kconfig
>@@ -5,5 +5,8 @@ config SYS_TEXT_BASE
>
> config BOARD_SPECIFIC_OPTIONS # dummy
> def_bool y
>+ imply VIRTIO_MMIO
>+ imply VIRTIO_NET
>+ imply VIRTIO_BLK
I think we should have VIRTIO_PCI here as well, so that QEMU command lines
that work on x86 will work on ARM just as well.
...
> --- a/board/emulation/qemu-arm/qemu-arm.c
> +++ b/board/emulation/qemu-arm/qemu-arm.c
> @@ -4,6 +4,7 @@
> */
> #include <common.h>
> #include <fdtdec.h>
> +#include <virtio.h>
>
> #ifdef CONFIG_ARM64
> #include <asm/armv8/mmu.h>
> @@ -58,6 +59,12 @@ struct mm_region *mem_map = qemu_arm64_mem_map;
>
> int board_init(void)
> {
> + /*
> + * Make sure virtio bus is enumerated so that peripherals
> + * on the virtio bus can be discovered by their drivers
> + */
> + virtio_init();
> +
> return 0;
> }
>
>
Note that in include/configs/qemu-arm.h, the boards auto-enumerate
PCI devices with a different mechanism, like this:
#define CONFIG_PREBOOT "pci enum"
I am not sure which one is better but at least we should be consistent.
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 18/27] riscv: qemu: Include some useful commands
2018-09-23 13:42 ` [U-Boot] [PATCH 18/27] riscv: qemu: Include some useful commands Bin Meng
2018-09-27 13:42 ` Simon Glass
@ 2018-09-27 22:14 ` Tuomas Tynkkynen
2018-10-02 16:03 ` Bin Meng
1 sibling, 1 reply; 82+ messages in thread
From: Tuomas Tynkkynen @ 2018-09-27 22:14 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 09/23/2018 04:42 PM, Bin Meng wrote:
> With the virtio net and blk drivers, we can do more stuff with some
> useful commands. Imply those in the board Kconfig.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> board/emulation/qemu-riscv/Kconfig | 8 ++++++++
> 1 file changed, 8 insertions(+)
>
> diff --git a/board/emulation/qemu-riscv/Kconfig b/board/emulation/qemu-riscv/Kconfig
> index 5ae56da..37a80db 100644
> --- a/board/emulation/qemu-riscv/Kconfig
> +++ b/board/emulation/qemu-riscv/Kconfig
> @@ -21,5 +21,13 @@ config BOARD_SPECIFIC_OPTIONS # dummy
> imply VIRTIO_MMIO
> imply VIRTIO_NET
> imply VIRTIO_BLK
> + imply CMD_PING
> + imply CMD_FS_GENERIC
> + imply DOS_PARTITION
> + imply EFI_PARTITION
> + imply ISO_PARTITION
> + imply CMD_EXT2
> + imply CMD_EXT4
> + imply CMD_FAT
>
> endif
>
How about using DISTRO_DEFAULTS?
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support
2018-09-27 13:43 ` [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Simon Glass
@ 2018-09-27 22:19 ` Tuomas Tynkkynen
2018-10-02 11:21 ` Simon Glass
0 siblings, 1 reply; 82+ messages in thread
From: Tuomas Tynkkynen @ 2018-09-27 22:19 UTC (permalink / raw)
To: u-boot
Hi Simon,
On 09/27/2018 04:43 PM, Simon Glass wrote:
...
>
> How does this all get tested? Could we have a simple sandbox driver?
>
We can switch the Travis-CI jobs for the QEMU boards to use virtio-net
instead of the current network cards for the TFTP tests. I don't know
if there are pytest equivalents for block devices.
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support
2018-09-27 22:19 ` Tuomas Tynkkynen
@ 2018-10-02 11:21 ` Simon Glass
2018-10-04 7:00 ` Bin Meng
0 siblings, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-10-02 11:21 UTC (permalink / raw)
To: u-boot
Hi,
On 27 September 2018 at 15:19, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi> wrote:
> Hi Simon,
>
> On 09/27/2018 04:43 PM, Simon Glass wrote:
> ...
>>
>>
>> How does this all get tested? Could we have a simple sandbox driver?
>>
>
> We can switch the Travis-CI jobs for the QEMU boards to use virtio-net
> instead of the current network cards for the TFTP tests. I don't know
> if there are pytest equivalents for block devices.
We do actually have sandbox block devices and can add anything that is
needed. While qemu is helpful, I much prefer tests that run with 'make
tests'.
Regards,
Simon
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management
2018-09-27 22:11 ` Tuomas Tynkkynen
@ 2018-10-02 15:46 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-02 15:46 UTC (permalink / raw)
To: u-boot
Hi Tuomas,
On Fri, Sep 28, 2018 at 6:11 AM Tuomas Tynkkynen
<tuomas.tynkkynen@iki.fi> wrote:
>
> Hi Bin,
>
> On 09/23/2018 04:42 PM, Bin Meng wrote:
> > From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> >
> > This adds support for managing virtual queue/ring, the channel
> > for high performance I/O between host and guest.
> >
> > Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> ...
>
> > +
> > +/*
> > + * Barriers in virtio are tricky. Since we are not in a hyperviosr/guest
> > + * scenario, having these as nops is enough to work as expected.
> > + */
> > +
> > +static inline void virtio_mb(void)
> > +{
> > +}
> > +
> > +static inline void virtio_rmb(void)
> > +{
> > +}
> > +
> > +static inline void virtio_wmb(void)
> > +{
> > +}
> > +
> > +static inline void virtio_store_mb(__virtio16 *p, __virtio16 v)
> > +{
> > + WRITE_ONCE(*p, v);
> > +}
> > +
> > +#endif /* _LINUX_VIRTIO_RING_H */
> >
> I am not convinced it's safe to leave these barriers empty. For instance
> if KVM acceleration is used, I believe U-Boot could be running on one
> core concurrently with QEMU's IO thread running on a different core.
> Thus we need memory barriers on both sides so that updates to the
> vring are observed in the correct order.
I think KVM acceleration only applies if hypervisor/guest are of the
same architecture. So far we are not using QEMU this way, even in QEMU
x86. Hence I believe barriers are not needed.
Regards,
Bin
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 18/27] riscv: qemu: Include some useful commands
2018-09-27 22:14 ` Tuomas Tynkkynen
@ 2018-10-02 16:03 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-02 16:03 UTC (permalink / raw)
To: u-boot
Hi Tuomas,
On Fri, Sep 28, 2018 at 6:14 AM Tuomas Tynkkynen
<tuomas.tynkkynen@iki.fi> wrote:
>
> Hi Bin,
>
> On 09/23/2018 04:42 PM, Bin Meng wrote:
> > With the virtio net and blk drivers, we can do more stuff with some
> > useful commands. Imply those in the board Kconfig.
> >
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> >
> > board/emulation/qemu-riscv/Kconfig | 8 ++++++++
> > 1 file changed, 8 insertions(+)
> >
> > diff --git a/board/emulation/qemu-riscv/Kconfig b/board/emulation/qemu-riscv/Kconfig
> > index 5ae56da..37a80db 100644
> > --- a/board/emulation/qemu-riscv/Kconfig
> > +++ b/board/emulation/qemu-riscv/Kconfig
> > @@ -21,5 +21,13 @@ config BOARD_SPECIFIC_OPTIONS # dummy
> > imply VIRTIO_MMIO
> > imply VIRTIO_NET
> > imply VIRTIO_BLK
> > + imply CMD_PING
> > + imply CMD_FS_GENERIC
> > + imply DOS_PARTITION
> > + imply EFI_PARTITION
> > + imply ISO_PARTITION
> > + imply CMD_EXT2
> > + imply CMD_EXT4
> > + imply CMD_FAT
> >
> > endif
> >
>
> How about using DISTRO_DEFAULTS?
At present U-Boot on RISC-V cannot boot Linux directly, so I am a
little bit concerned turning on DISTRO_DEFAULTS may confuse people. We
may revisit this when directly Linux booting is supported.
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 05/27] virtio: Add net driver support
2018-09-27 22:12 ` Tuomas Tynkkynen
@ 2018-10-02 16:10 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-02 16:10 UTC (permalink / raw)
To: u-boot
Hi Tuomas,
On Fri, Sep 28, 2018 at 6:12 AM Tuomas Tynkkynen
<tuomas.tynkkynen@iki.fi> wrote:
>
> Hi Bin,
>
> On 09/23/2018 04:42 PM, Bin Meng wrote:
> > From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> >
> > This adds virtio net device driver support.
> >
> > Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> ...
> > +static u32 feature[] = {
> > + VIRTIO_NET_F_MAC
> > +};
> > +
> > +static u32 feature_legacy[] = {
> > + VIRTIO_NET_F_MAC
> > +};
>
> These can be const.
>
Will do in v2.
> ...
> > +
> > +static void virtio_net_stop(struct udevice *dev)
> > +{
> > + /*
> > + * There is no way to stop the queue from running, unless we issue
> > + * a reset to the virtio device, and re-do the queue initialization
> > + * from the beginning.
> > + */
> > +}
>
> Unless I missed it, we still need to do something when we pass control to
> Linux so that the memory used for receive buffers doesn't get overwritten
> by the virtio device during Linux boot.
>
Yes, you are correct.
> I think this can be done by calling virtio_reset() on the device in some
> uclass-level hook, maybe .child_post_remove().
Will do in v2.
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support
2018-10-02 11:21 ` Simon Glass
@ 2018-10-04 7:00 ` Bin Meng
2018-10-09 16:20 ` Simon Glass
0 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-10-04 7:00 UTC (permalink / raw)
To: u-boot
Hi Simon,
On Tue, Oct 2, 2018 at 7:22 PM Simon Glass <sjg@chromium.org> wrote:
>
> Hi,
>
> On 27 September 2018 at 15:19, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi> wrote:
> > Hi Simon,
> >
> > On 09/27/2018 04:43 PM, Simon Glass wrote:
> > ...
> >>
> >>
> >> How does this all get tested? Could we have a simple sandbox driver?
> >>
> >
> > We can switch the Travis-CI jobs for the QEMU boards to use virtio-net
> > instead of the current network cards for the TFTP tests. I don't know
> > if there are pytest equivalents for block devices.
>
> We do actually have sandbox block devices and can add anything that is
> needed. While qemu is helpful, I much prefer tests that run with 'make
> tests'.
I had a look at the testing on sandbox. It looks to me that we need
introduce a non-existent virtio transport sandbox emulator to support
this. I am not sure this is worth to do so. As Tuomas mentioned we can
setup travis-ci to test on qemu targets.
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support
2018-10-04 7:00 ` Bin Meng
@ 2018-10-09 16:20 ` Simon Glass
2018-10-10 15:35 ` Bin Meng
0 siblings, 1 reply; 82+ messages in thread
From: Simon Glass @ 2018-10-09 16:20 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 4 October 2018 at 01:00, Bin Meng <bmeng.cn@gmail.com> wrote:
> Hi Simon,
>
> On Tue, Oct 2, 2018 at 7:22 PM Simon Glass <sjg@chromium.org> wrote:
>>
>> Hi,
>>
>> On 27 September 2018 at 15:19, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi> wrote:
>> > Hi Simon,
>> >
>> > On 09/27/2018 04:43 PM, Simon Glass wrote:
>> > ...
>> >>
>> >>
>> >> How does this all get tested? Could we have a simple sandbox driver?
>> >>
>> >
>> > We can switch the Travis-CI jobs for the QEMU boards to use virtio-net
>> > instead of the current network cards for the TFTP tests. I don't know
>> > if there are pytest equivalents for block devices.
>>
>> We do actually have sandbox block devices and can add anything that is
>> needed. While qemu is helpful, I much prefer tests that run with 'make
>> tests'.
>
> I had a look at the testing on sandbox. It looks to me that we need
> introduce a non-existent virtio transport sandbox emulator to support
> this. I am not sure this is worth to do so. As Tuomas mentioned we can
> setup travis-ci to test on qemu targets.
I would like to have at least some basic testing of each uclass within
U-Boot without relying on qemu, which after all is a much more
complicated test. We have created simple sandbox drivers other
uclasses and I don't see a good reason why virtio should be different?
There are only 11 methods in the uclass so it should not be a huge
amount of work to call each one. I certainly understand the burden of
this, but I think it will pay off.
Regards,
Simon
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support
2018-10-09 16:20 ` Simon Glass
@ 2018-10-10 15:35 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-10 15:35 UTC (permalink / raw)
To: u-boot
Hi Simon,
On Wed, Oct 10, 2018 at 12:20 AM Simon Glass <sjg@chromium.org> wrote:
>
> Hi Bin,
>
> On 4 October 2018 at 01:00, Bin Meng <bmeng.cn@gmail.com> wrote:
> > Hi Simon,
> >
> > On Tue, Oct 2, 2018 at 7:22 PM Simon Glass <sjg@chromium.org> wrote:
> >>
> >> Hi,
> >>
> >> On 27 September 2018 at 15:19, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi> wrote:
> >> > Hi Simon,
> >> >
> >> > On 09/27/2018 04:43 PM, Simon Glass wrote:
> >> > ...
> >> >>
> >> >>
> >> >> How does this all get tested? Could we have a simple sandbox driver?
> >> >>
> >> >
> >> > We can switch the Travis-CI jobs for the QEMU boards to use virtio-net
> >> > instead of the current network cards for the TFTP tests. I don't know
> >> > if there are pytest equivalents for block devices.
> >>
> >> We do actually have sandbox block devices and can add anything that is
> >> needed. While qemu is helpful, I much prefer tests that run with 'make
> >> tests'.
> >
> > I had a look at the testing on sandbox. It looks to me that we need
> > introduce a non-existent virtio transport sandbox emulator to support
> > this. I am not sure this is worth to do so. As Tuomas mentioned we can
> > setup travis-ci to test on qemu targets.
>
> I would like to have at least some basic testing of each uclass within
> U-Boot without relying on qemu, which after all is a much more
> complicated test. We have created simple sandbox drivers other
> uclasses and I don't see a good reason why virtio should be different?
> There are only 11 methods in the uclass so it should not be a huge
> amount of work to call each one. I certainly understand the burden of
> this, but I think it will pay off.
>
OK, will try to add a simple virtio sandbox driver to validate the API usage.
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 01/27] dm: core: Allow uclass to set up a device's child after it is probed
2018-09-27 13:41 ` Simon Glass
@ 2018-10-11 5:14 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-11 5:14 UTC (permalink / raw)
To: u-boot
Hi Simon,
On Thu, Sep 27, 2018 at 9:42 PM Simon Glass <sjg@chromium.org> wrote:
>
> Hi Bin,
>
> On 23 September 2018 at 06:41, Bin Meng <bmeng.cn@gmail.com> wrote:
> > Some buses need to set up their child devices after they are probed.
> > Support a common child_post_probe() method for the uclass.
> >
> > With this change, the two APIs uclass_pre_probe_device() and
> > uclass_post_probe_device() become symmetric.
> >
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> >
> > drivers/core/uclass.c | 13 ++++++++++++-
> > include/dm/uclass.h | 4 +++-
> > 2 files changed, 15 insertions(+), 2 deletions(-)
>
> Another option, perhaps not quite as elegant, is for the driver to
> call into the uclass in its probe() method. We need to balance
> elegance with the cost of adding a new field to the uclass which is
> rarely used. What do you think?
>
Yes, we can use driver's probe() method to achieve the same goal, but
that seems a little bit duplicated effort for every driver. Also I
believe we should make uclass_pre_probe_device() and
uclass_post_probe_device() symmetric.
> Also, this does need some sort of use in sandbox, so can you update
> the test driver to use it?
>
Yes, will add in v2.
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices
2018-09-27 13:42 ` Simon Glass
@ 2018-10-11 9:08 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-11 9:08 UTC (permalink / raw)
To: u-boot
Hi Simon,
On Thu, Sep 27, 2018 at 9:42 PM Simon Glass <sjg@chromium.org> wrote:
>
> Hi Bin,
>
> On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> > This adds a new virtio uclass driver for “virtio” [1] family of
> > devices that are are found in virtual environments like QEMU,
> > yet by design they look like physical devices to the guest.
> >
> > The uclass driver provides child_pre_probe() and child_post_probe()
> > methods to do some common operations for virtio device drivers like
> > device and driver supported feature negotiation, etc.
> >
> > [1] http://docs.oasis-open.org/virtio/virtio/v1.0/virtio-v1.0.pdf
>
> Can you add this link to the header file too? This seems to be lacking
> docs.in the source code. Also in a header file, a short statement of
> what virtio is for would be good.
>
Will add the link and a short statement for VirtIO in virtio.h,
virtio-uclass.c and driver/virtio/Kconfig in v2.
> >
> > Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> >
> > drivers/Kconfig | 2 +
> > drivers/Makefile | 1 +
> > drivers/virtio/Kconfig | 14 +
> > drivers/virtio/Makefile | 6 +
> > drivers/virtio/virtio-uclass.c | 333 ++++++++++++++++++++
> > include/dm/uclass-id.h | 1 +
> > include/virtio.h | 694 +++++++++++++++++++++++++++++++++++++++++
> > include/virtio_types.h | 24 ++
> > 8 files changed, 1075 insertions(+)
> > create mode 100644 drivers/virtio/Kconfig
> > create mode 100644 drivers/virtio/Makefile
> > create mode 100644 drivers/virtio/virtio-uclass.c
> > create mode 100644 include/virtio.h
> > create mode 100644 include/virtio_types.h
> >
> > diff --git a/drivers/Kconfig b/drivers/Kconfig
> > index 56536c4..d40db0d 100644
> > --- a/drivers/Kconfig
> > +++ b/drivers/Kconfig
> > @@ -106,6 +106,8 @@ source "drivers/usb/Kconfig"
> >
> > source "drivers/video/Kconfig"
> >
> > +source "drivers/virtio/Kconfig"
> > +
> > source "drivers/watchdog/Kconfig"
> >
> > config PHYS_TO_BUS
> > diff --git a/drivers/Makefile b/drivers/Makefile
> > index 23ea609..f09daae 100644
> > --- a/drivers/Makefile
> > +++ b/drivers/Makefile
> > @@ -14,6 +14,7 @@ obj-$(CONFIG_$(SPL_TPL_)SERIAL_SUPPORT) += serial/
> > obj-$(CONFIG_$(SPL_TPL_)SPI_FLASH_SUPPORT) += mtd/spi/
> > obj-$(CONFIG_$(SPL_TPL_)SPI_SUPPORT) += spi/
> > obj-$(CONFIG_$(SPL_TPL_)TIMER) += timer/
> > +obj-$(CONFIG_$(SPL_TPL_)VIRTIO) += virtio/
> > obj-$(CONFIG_$(SPL_)DM_MAILBOX) += mailbox/
> > obj-$(CONFIG_$(SPL_)REMOTEPROC) += remoteproc/
> >
> > diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
> > new file mode 100644
> > index 0000000..bdfa96a
> > --- /dev/null
> > +++ b/drivers/virtio/Kconfig
> > @@ -0,0 +1,14 @@
> > +# SPDX-License-Identifier: GPL-2.0+
> > +#
> > +# Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > +# Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> > +
> > +menu "VirtIO Drivers"
> > +
> > +config VIRTIO
> > + bool
> > + help
> > + This option is selected by any driver which implements the virtio
> > + bus, such as CONFIG_VIRTIO_MMIO or CONFIG_VIRTIO_PCI.
>
> What is a virtio bus?
>
Change to transport in v2, as suggested by Tuomas.
> > +
> > +endmenu
> > diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
> > new file mode 100644
> > index 0000000..23e7be7
> > --- /dev/null
> > +++ b/drivers/virtio/Makefile
> > @@ -0,0 +1,6 @@
> > +# SPDX-License-Identifier: GPL-2.0+
> > +#
> > +# Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > +# Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> > +
> > +obj-y += virtio-uclass.o
> > diff --git a/drivers/virtio/virtio-uclass.c b/drivers/virtio/virtio-uclass.c
> > new file mode 100644
> > index 0000000..1c85856
> > --- /dev/null
> > +++ b/drivers/virtio/virtio-uclass.c
> > @@ -0,0 +1,333 @@
> > +// SPDX-License-Identifier: GPL-2.0+
> > +/*
> > + * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > + * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> > + */
> > +
> > +#include <common.h>
> > +#include <dm.h>
> > +#include <virtio.h>
> > +#include <dm/device.h>
> > +#include <dm/lists.h>
> > +
> > +static const char *const virtio_drv_name[VIRTIO_ID_MAX_NUM] = {
> > + [VIRTIO_ID_NET] = VIRTIO_NET_DRV_NAME,
> > + [VIRTIO_ID_BLOCK] = VIRTIO_BLK_DRV_NAME,
> > +};
> > +
> > +int virtio_get_config(struct udevice *vdev, unsigned int offset,
> > + void *buf, unsigned int len)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->get_config)
> > + return -ENOSYS;
>
> blank line before return (fix globally)
>
Fixed this in v2. However as Tuomas suggested, I added another check
in the uclass' pre_probe method to check these ops once and for all so
most of these checks here are unnecessary in v2.
> > + return ops->get_config(vdev->parent, offset, buf, len);
> > +}
> > +
> > +int virtio_set_config(struct udevice *vdev, unsigned int offset,
> > + void *buf, unsigned int len)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->set_config)
> > + return -ENOSYS;
> > + return ops->set_config(vdev->parent, offset, buf, len);
> > +}
> > +
> > +int virtio_generation(struct udevice *vdev, u32 *counter)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->generation)
> > + return -ENOSYS;
> > + return ops->generation(vdev->parent, counter);
> > +}
> > +
> > +int virtio_get_status(struct udevice *vdev, u8 *status)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->get_status)
> > + return -ENOSYS;
> > + return ops->get_status(vdev->parent, status);
> > +}
> > +
> > +int virtio_set_status(struct udevice *vdev, u8 status)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->set_status)
> > + return -ENOSYS;
> > + return ops->set_status(vdev->parent, status);
> > +}
> > +
> > +int virtio_reset(struct udevice *vdev)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->reset)
> > + return -ENOSYS;
> > + return ops->reset(vdev->parent);
> > +}
> > +
> > +int virtio_get_features(struct udevice *vdev, u64 *features)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->get_features)
> > + return -ENOSYS;
> > + return ops->get_features(vdev->parent, features);
> > +}
> > +
> > +int virtio_set_features(struct udevice *vdev)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->set_features)
> > + return -ENOSYS;
> > + return ops->set_features(vdev->parent);
> > +}
> > +
> > +int virtio_find_vqs(struct udevice *vdev, unsigned int nvqs,
> > + struct virtqueue *vqs[])
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->find_vqs)
> > + return -ENOSYS;
> > + return ops->find_vqs(vdev->parent, nvqs, vqs);
> > +}
> > +
> > +int virtio_del_vqs(struct udevice *vdev)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->del_vqs)
> > + return -ENOSYS;
> > + return ops->del_vqs(vdev->parent);
> > +}
> > +
> > +int virtio_notify(struct udevice *vdev, struct virtqueue *vq)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->notify)
> > + return -ENOSYS;
> > + return ops->notify(vdev->parent, vq);
> > +}
> > +
> > +void virtio_add_status(struct udevice *vdev, u8 status)
> > +{
> > + u8 old;
> > +
> > + if (!virtio_get_status(vdev, &old))
> > + virtio_set_status(vdev, old | status);
> > +}
> > +
> > +int virtio_finalize_features(struct udevice *vdev)
> > +{
> > + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
> > + u8 status;
> > + int ret;
> > +
> > + ret = virtio_set_features(vdev);
> > + if (ret)
> > + return ret;
> > +
> > + if (uc_priv->legacy)
> > + return 0;
> > +
> > + virtio_add_status(vdev, VIRTIO_CONFIG_S_FEATURES_OK);
> > + ret = virtio_get_status(vdev, &status);
> > + if (ret)
> > + return ret;
> > + if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
> > + debug("(%s): device refuses features %x\n", vdev->name, status);
> > + return -ENODEV;
> > + }
> > +
> > + return 0;
> > +}
> > +
> > +void virtio_driver_features_init(struct virtio_dev_priv *priv,
> > + u32 *feature, u32 feature_size,
> > + u32 *feature_legacy, u32 feature_legacy_size)
> > +{
> > + priv->feature_table = feature;
> > + priv->feature_table_size = feature_size;
> > + priv->feature_table_legacy = feature_legacy;
> > + priv->feature_table_size_legacy = feature_legacy_size;
> > +}
> > +
> > +void virtio_init(void)
>
> Shouldn't this return int if there is an error?
>
Changed in v2.
> > +{
> > + struct udevice *bus;
> > +
> > + /* Enumerate all known virtio devices */
> > + for (uclass_first_device(UCLASS_VIRTIO, &bus);
> > + bus;
> > + uclass_next_device(&bus)) {
> > + ;
> > + }
> > +}
> > +
> > +static int virtio_uclass_post_probe(struct udevice *udev)
> > +{
> > + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
> > + char dev_name[30], *str;
> > + struct udevice *vdev;
> > + int ret;
> > +
> > + if (uc_priv->device > VIRTIO_ID_MAX_NUM) {
> > + debug("(%s): virtio device ID %d exceeds maximum num\n",
> > + udev->name, uc_priv->device);
> > + return 0;
> > + }
> > +
> > + if (!virtio_drv_name[uc_priv->device]) {
> > + debug("(%s): underlying virtio device driver unavailable\n",
> > + udev->name);
> > + return 0;
> > + }
> > +
> > + snprintf(dev_name, sizeof(dev_name), "%s#%d",
> > + virtio_drv_name[uc_priv->device], udev->seq);
> > + str = strdup(dev_name);
> > + if (!str)
> > + return -ENOMEM;
>
> You might consider using log_ret() or log_msg_ret() for your error returns
>
Keep this for now as currently log_msg_ret() does not build.
> > +
> > + ret = device_bind_driver(udev, virtio_drv_name[uc_priv->device],
> > + str, &vdev);
> > + if (ret == -ENOENT) {
> > + debug("(%s): no driver configured\n", udev->name);
> > + return 0;
> > + }
> > + if (ret) {
> > + free(str);
> > + return ret;
> > + }
> > + device_set_name_alloced(vdev);
> > +
> > + return 0;
> > +}
> > +
> > +static int virtio_uclass_child_post_bind(struct udevice *vdev)
> > +{
> > + /* Acknowledge that we've seen the device */
> > + virtio_add_status(vdev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
>
> Not sure this is worth having a new hook?
>
> > +
> > + return 0;
> > +}
> > +
> > +static int virtio_uclass_child_pre_probe(struct udevice *vdev)
> > +{
> > + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
> > + u64 device_features;
> > + u64 driver_features;
> > + u64 driver_features_legacy;
> > + int i;
> > + int ret;
> > +
> > + /*
> > + * Save the real virtio device (eg: virtio-net, virtio-blk) to
> > + * the transport (parent) device's uclass priv for future use.
> > + */
> > + uc_priv->vdev = vdev;
> > +
> > + /*
> > + * We always start by resetting the device, in case a previous driver
> > + * messed it up. This also tests that code path a little.
> > + */
> > + ret = virtio_reset(vdev);
> > + if (ret)
> > + goto err;
> > +
> > + /* We have a driver! */
> > + virtio_add_status(vdev, VIRTIO_CONFIG_S_DRIVER);
> > +
> > + /* Figure out what features the device supports */
> > + virtio_get_features(vdev, &device_features);
> > + debug("(%s) plain device features supported %016llx\n",
> > + vdev->name, device_features);
> > + if (!(device_features & (1ULL << VIRTIO_F_VERSION_1)))
> > + uc_priv->legacy = true;
> > +
> > + /* Figure out what features the driver supports */
> > + driver_features = 0;
> > + for (i = 0; i < uc_priv->feature_table_size; i++) {
> > + unsigned int f = uc_priv->feature_table[i];
> > +
> > + WARN_ON(f >= 64);
> > + driver_features |= (1ULL << f);
> > + }
> > +
> > + /* Some drivers have a separate feature table for virtio v1.0 */
> > + if (uc_priv->feature_table_legacy) {
> > + driver_features_legacy = 0;
> > + for (i = 0; i < uc_priv->feature_table_size_legacy; i++) {
> > + unsigned int f = uc_priv->feature_table_legacy[i];
> > +
> > + WARN_ON(f >= 64);
> > + driver_features_legacy |= (1ULL << f);
> > + }
> > + } else {
> > + driver_features_legacy = driver_features;
> > + }
> > +
> > + if (uc_priv->legacy) {
> > + debug("(%s): legacy virtio device\n", vdev->name);
> > + uc_priv->features = driver_features_legacy & device_features;
> > + } else {
> > + debug("(%s): v1.0 complaint virtio device\n", vdev->name);
> > + uc_priv->features = driver_features & device_features;
> > + }
> > +
> > + /* Transport features always preserved to pass to finalize_features */
> > + for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)
> > + if ((device_features & (1ULL << i)) &&
> > + (i == VIRTIO_F_VERSION_1))
> > + __virtio_set_bit(vdev->parent, i);
> > +
> > + debug("(%s) final negotiated features supported %016llx\n",
> > + vdev->name, uc_priv->features);
> > + ret = virtio_finalize_features(vdev);
> > + if (ret)
> > + goto err;
> > +
> > + return 0;
> > +
> > +err:
> > + virtio_add_status(vdev, VIRTIO_CONFIG_S_FAILED);
> > + return ret;
> > +}
> > +
> > +static int virtio_uclass_child_post_probe(struct udevice *vdev)
> > +{
> > + /* Indicates that the driver is set up and ready to drive the device */
> > + virtio_add_status(vdev, VIRTIO_CONFIG_S_DRIVER_OK);
> > +
> > + return 0;
> > +}
> > +
> > +UCLASS_DRIVER(virtio) = {
> > + .name = "virtio",
> > + .id = UCLASS_VIRTIO,
> > + .flags = DM_UC_FLAG_SEQ_ALIAS,
> > + .post_probe = virtio_uclass_post_probe,
> > + .child_post_bind = virtio_uclass_child_post_bind,
> > + .child_pre_probe = virtio_uclass_child_pre_probe,
> > + .child_post_probe = virtio_uclass_child_post_probe,
> > + .per_device_auto_alloc_size = sizeof(struct virtio_dev_priv),
> > +};
> > diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h
> > index 7027ea0..08b2a8f 100644
> > --- a/include/dm/uclass-id.h
> > +++ b/include/dm/uclass-id.h
> > @@ -93,6 +93,7 @@ enum uclass_id {
> > UCLASS_VIDEO_BRIDGE, /* Video bridge, e.g. DisplayPort to LVDS */
> > UCLASS_VIDEO_CONSOLE, /* Text console driver for video device */
> > UCLASS_WDT, /* Watchdot Timer driver */
> > + UCLASS_VIRTIO, /* VirtIO transport device */
>
> V before W :-)
>
Fixed in v2.
> >
> > UCLASS_COUNT,
> > UCLASS_INVALID = -1,
> > diff --git a/include/virtio.h b/include/virtio.h
> > new file mode 100644
> > index 0000000..efbedb2
> > --- /dev/null
> > +++ b/include/virtio.h
> > @@ -0,0 +1,694 @@
> > +/* SPDX-License-Identifier: GPL-2.0+ */
> > +/*
> > + * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > + * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> > + *
> > + * This file is largely based on Linux kernel virtio_*.h files
> > + */
> > +
> > +#ifndef __VIRTIO_H__
> > +#define __VIRTIO_H__
> > +
> > +#include <virtio_types.h>
> > +#include <dm/device.h>
>
> Should be able to avoid this, just put in C file
>
Fixed in v2.
> > +
> > +#define VIRTIO_ID_NET 1 /* virtio net */
> > +#define VIRTIO_ID_BLOCK 2 /* virtio block */
> > +#define VIRTIO_ID_MAX_NUM 3
> > +
> > +#define VIRTIO_NET_DRV_NAME "virtio-net"
> > +#define VIRTIO_BLK_DRV_NAME "virtio-blk"
> > +
> > +/* Status byte for guest to report progress, and synchronize features */
> > +
> > +/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
> > +#define VIRTIO_CONFIG_S_ACKNOWLEDGE 1
> > +/* We have found a driver for the device */
> > +#define VIRTIO_CONFIG_S_DRIVER 2
> > +/* Driver has used its parts of the config, and is happy */
> > +#define VIRTIO_CONFIG_S_DRIVER_OK 4
> > +/* Driver has finished configuring features */
> > +#define VIRTIO_CONFIG_S_FEATURES_OK 8
> > +/* Device entered invalid state, driver must reset it */
> > +#define VIRTIO_CONFIG_S_NEEDS_RESET 0x40
> > +/* We've given up on this device */
> > +#define VIRTIO_CONFIG_S_FAILED 0x80
> > +
> > +/*
> > + * Virtio feature bits VIRTIO_TRANSPORT_F_START through VIRTIO_TRANSPORT_F_END
> > + * are reserved for the transport being used (eg: virtio_ring, virtio_pci etc.),
> > + * the rest are per-device feature bits.
> > + */
> > +#define VIRTIO_TRANSPORT_F_START 28
> > +#define VIRTIO_TRANSPORT_F_END 38
> > +
> > +#ifndef VIRTIO_CONFIG_NO_LEGACY
> > +/*
> > + * Do we get callbacks when the ring is completely used,
> > + * even if we've suppressed them?
> > + */
> > +#define VIRTIO_F_NOTIFY_ON_EMPTY 24
> > +
> > +/* Can the device handle any descriptor layout? */
> > +#define VIRTIO_F_ANY_LAYOUT 27
> > +#endif /* VIRTIO_CONFIG_NO_LEGACY */
> > +
> > +/* v1.0 compliant */
> > +#define VIRTIO_F_VERSION_1 32
> > +
> > +/*
> > + * If clear - device has the IOMMU bypass quirk feature.
> > + * If set - use platform tools to detect the IOMMU.
> > + *
> > + * Note the reverse polarity (compared to most other features),
> > + * this is for compatibility with legacy systems.
> > + */
> > +#define VIRTIO_F_IOMMU_PLATFORM 33
> > +
> > +/* Does the device support Single Root I/O Virtualization? */
> > +#define VIRTIO_F_SR_IOV 37
> > +
> > +/**
> > + * virtio scatter-gather struct
> > + *
> > + * @addr: sg buffer address
> > + * @lengh: sg buffer length
> > + */
> > +struct virtio_sg {
> > + void *addr;
> > + size_t length;
> > +};
> > +
> > +struct virtqueue;
> > +
> > +/* virtio bus operations */
> > +struct dm_virtio_ops {
> > + /**
> > + * get_config() - read the value of a configuration field
> > + *
> > + * @vdev: the real virtio device
> > + * @offset: the offset of the configuration field
> > + * @buf: the buffer to write the field value into
> > + * @len: the length of the buffer
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*get_config)(struct udevice *vdev, unsigned int offset,
> > + void *buf, unsigned int len);
> > + /**
> > + * set_config() - write the value of a configuration field
> > + *
> > + * @vdev: the real virtio device
> > + * @offset: the offset of the configuration field
> > + * @buf: the buffer to read the field value from
> > + * @len: the length of the buffer
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*set_config)(struct udevice *vdev, unsigned int offset,
> > + const void *buf, unsigned int len);
> > + /**
> > + * generation() - config generation counter
> > + *
> > + * @vdev: the real virtio device
> > + * @counter: the returned config generation counter
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*generation)(struct udevice *vdev, u32 *counter);
> > + /**
> > + * get_status() - read the status byte
> > + *
> > + * @vdev: the real virtio device
> > + * @status: the returned status byte
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*get_status)(struct udevice *vdev, u8 *status);
> > + /**
> > + * set_status() - write the status byte
> > + *
> > + * @vdev: the real virtio device
> > + * @status: the new status byte
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*set_status)(struct udevice *vdev, u8 status);
> > + /**
> > + * reset() - reset the device
> > + *
> > + * @vdev: the real virtio device
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*reset)(struct udevice *vdev);
> > + /**
> > + * get_features() - get the array of feature bits for this device
> > + *
> > + * @vdev: the real virtio device
> > + * @features: the first 32 feature bits (all we currently need)
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*get_features)(struct udevice *vdev, u64 *features);
> > + /**
> > + * set_features() - confirm what device features we'll be using
> > + *
> > + * @vdev: the real virtio device
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*set_features)(struct udevice *vdev);
> > + /**
> > + * find_vqs() - find virtqueues and instantiate them
> > + *
> > + * @vdev: the real virtio device
> > + * @nvqs: the number of virtqueues to find
> > + * @vqs: on success, includes new virtqueues
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*find_vqs)(struct udevice *vdev, unsigned int nvqs,
> > + struct virtqueue *vqs[]);
> > + /**
> > + * del_vqs() - free virtqueues found by find_vqs()
> > + *
> > + * @vdev: the real virtio device
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*del_vqs)(struct udevice *vdev);
> > + /**
> > + * notify() - notify the device to process the queue
> > + *
> > + * @vdev: the real virtio device
> > + * @vq: virtqueue to process
> > + * @return 0 if OK, -ve on error
> > + */
> > + int (*notify)(struct udevice *vdev, struct virtqueue *vq);
> > +};
> > +
> > +/* Get access to a virtio bus' operations */
> > +#define virtio_get_ops(dev) ((struct dm_virtio_ops *)(dev)->driver->ops)
> > +
> > +/**
> > + * virtio uclass per device private data
> > + *
> > + * @vqs: virtualqueue for the virtio device
> > + * @vdev: the real virtio device underneath
> > + * @legacy: is it a legacy device?
> > + * @device: virtio device ID
> > + * @vendor: virtio vendor ID
> > + * @features: negotiated supported features
> > + * @feature_table: an array of feature supported by the driver
> > + * @feature_table_size: number of entries in the feature table array
> > + * @feature_table_legacy: same as feature_table but working in legacy mode
> > + * @feature_table_size_legacy: number of entries in feature table legacy array
> > + */
> > +struct virtio_dev_priv {
> > + struct list_head vqs;
> > + struct udevice *vdev;
> > + bool legacy;
> > + u32 device;
> > + u32 vendor;
> > + u64 features;
> > + u32 *feature_table;
> > + u32 feature_table_size;
> > + u32 *feature_table_legacy;
> > + u32 feature_table_size_legacy;
> > +};
> > +
> > +/**
> > + * virtio_get_config() - read the value of a configuration field
> > + *
> > + * @vdev: the real virtio device
> > + * @offset: the offset of the configuration field
> > + * @buf: the buffer to write the field value into
> > + * @len: the length of the buffer
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_get_config(struct udevice *vdev, unsigned int offset,
> > + void *buf, unsigned int len);
> > +
> > +/**
> > + * virtio_set_config() - write the value of a configuration field
> > + *
> > + * @vdev: the real virtio device
> > + * @offset: the offset of the configuration field
> > + * @buf: the buffer to read the field value from
> > + * @len: the length of the buffer
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_set_config(struct udevice *vdev, unsigned int offset,
> > + void *buf, unsigned int len);
> > +
> > +/**
> > + * virtio_generation() - config generation counter
> > + *
> > + * @vdev: the real virtio device
> > + * @counter: the returned config generation counter
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_generation(struct udevice *vdev, u32 *counter);
> > +
> > +/**
> > + * virtio_get_status() - read the status byte
> > + *
> > + * @vdev: the real virtio device
> > + * @status: the returned status byte
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_get_status(struct udevice *vdev, u8 *status);
> > +
> > +/**
> > + * virtio_set_status() - write the status byte
> > + *
> > + * @vdev: the real virtio device
> > + * @status: the new status byte
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_set_status(struct udevice *vdev, u8 status);
> > +
> > +/**
> > + * virtio_reset() - reset the device
> > + *
> > + * @vdev: the real virtio device
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_reset(struct udevice *vdev);
> > +
> > +/**
> > + * virtio_get_features() - get the array of feature bits for this device
> > + *
> > + * @vdev: the real virtio device
> > + * @features: the first 32 feature bits (all we currently need)
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_get_features(struct udevice *vdev, u64 *features);
> > +
> > +/**
> > + * virtio_set_features() - confirm what device features we'll be using
> > + *
> > + * @vdev: the real virtio device
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_set_features(struct udevice *vdev);
> > +
> > +/**
> > + * virtio_find_vqs() - find virtqueues and instantiate them
> > + *
> > + * @vdev: the real virtio device
> > + * @nvqs: the number of virtqueues to find
> > + * @vqs: on success, includes new virtqueues
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_find_vqs(struct udevice *vdev, unsigned int nvqs,
> > + struct virtqueue *vqs[]);
> > +
> > +/**
> > + * virtio_del_vqs() - free virtqueues found by find_vqs()
> > + *
> > + * @vdev: the real virtio device
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_del_vqs(struct udevice *vdev);
> > +
> > +/**
> > + * virtio_notify() - notify the device to process the queue
> > + *
> > + * @vdev: the real virtio device
> > + * @vq: virtqueue to process
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_notify(struct udevice *vdev, struct virtqueue *vq);
> > +
> > +/**
> > + * virtio_add_status() - helper to set a new status code to the device
> > + *
> > + * @vdev: the real virtio device
> > + * @status: new status code to be added
> > + */
> > +void virtio_add_status(struct udevice *vdev, u8 status);
> > +
> > +/**
> > + * virtio_finalize_features() - helper to finalize features
> > + *
> > + * @vdev: the real virtio device
> > + * @return 0 if OK, -ve on error
> > + */
> > +int virtio_finalize_features(struct udevice *vdev);
> > +
> > +/**
> > + * virtio_driver_features_init() - initialize driver supported features
> > + *
> > + * This fills in the virtio device parent per child private data with the given
> > + * information, which contains driver supported features and legacy features.
> > + *
> > + * This API should be called in the virtio device driver's bind method, so that
> > + * later virtio transport uclass driver can utilize the driver supplied features
> > + * to negotiate with the device on the final supported features.
> > + *
> > + * @priv: virtio uclass per device private data
> > + * @feature: an array of feature supported by the driver
> > + * @feature_size: number of entries in the feature table array
> > + * @feature_legacy: same as feature_table but working in legacy mode
> > + * @feature_legacy_size:number of entries in feature table legacy array
> > + */
> > +void virtio_driver_features_init(struct virtio_dev_priv *priv,
> > + u32 *feature, u32 feature_size,
> > + u32 *feature_legacy, u32 feature_legacy_size);
> > +
> > +/**
> > + * virtio_init() - helper to enumerate all known virtio devices
> > + */
> > +void virtio_init(void);
> > +
> > +static inline u16 __virtio16_to_cpu(bool little_endian, __virtio16 val)
> > +{
> > + if (little_endian)
> > + return le16_to_cpu((__force __le16)val);
> > + else
> > + return be16_to_cpu((__force __be16)val);
> > +}
> > +
> > +static inline __virtio16 __cpu_to_virtio16(bool little_endian, u16 val)
> > +{
> > + if (little_endian)
> > + return (__force __virtio16)cpu_to_le16(val);
> > + else
> > + return (__force __virtio16)cpu_to_be16(val);
> > +}
> > +
> > +static inline u32 __virtio32_to_cpu(bool little_endian, __virtio32 val)
> > +{
> > + if (little_endian)
> > + return le32_to_cpu((__force __le32)val);
> > + else
> > + return be32_to_cpu((__force __be32)val);
> > +}
> > +
> > +static inline __virtio32 __cpu_to_virtio32(bool little_endian, u32 val)
> > +{
> > + if (little_endian)
> > + return (__force __virtio32)cpu_to_le32(val);
> > + else
> > + return (__force __virtio32)cpu_to_be32(val);
> > +}
> > +
> > +static inline u64 __virtio64_to_cpu(bool little_endian, __virtio64 val)
> > +{
> > + if (little_endian)
> > + return le64_to_cpu((__force __le64)val);
> > + else
> > + return be64_to_cpu((__force __be64)val);
> > +}
> > +
> > +static inline __virtio64 __cpu_to_virtio64(bool little_endian, u64 val)
> > +{
> > + if (little_endian)
> > + return (__force __virtio64)cpu_to_le64(val);
> > + else
> > + return (__force __virtio64)cpu_to_be64(val);
> > +}
> > +
> > +/**
> > + * __virtio_test_bit - helper to test feature bits
> > + *
> > + * For use by transports. Devices should normally use virtio_has_feature,
> > + * which includes more checks.
> > + *
> > + * @udev: the transport device
> > + * @fbit: the feature bit
> > + */
> > +static inline bool __virtio_test_bit(struct udevice *udev, unsigned int fbit)
> > +{
> > + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
> > +
> > + /* Did you forget to fix assumptions on max features? */
> > + if (__builtin_constant_p(fbit))
> > + BUILD_BUG_ON(fbit >= 64);
> > + else
> > + WARN_ON(fbit >= 64);
> > +
> > + return uc_priv->features & BIT_ULL(fbit);
>
> Why is this (and the ones below) inline? I worry this might bloat the
> code for no purpose?
>
These are from Linux header files and I plan to leave them as it is
for now, to keep sync with Linux version.
> > +}
> > +
> > +/**
> > + * __virtio_set_bit - helper to set feature bits
> > + *
> > + * For use by transports.
> > + *
> > + * @udev: the transport device
> > + * @fbit: the feature bit
> > + */
> > +static inline void __virtio_set_bit(struct udevice *udev, unsigned int fbit)
> > +{
> > + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
> > +
> > + /* Did you forget to fix assumptions on max features? */
> > + if (__builtin_constant_p(fbit))
> > + BUILD_BUG_ON(fbit >= 64);
> > + else
> > + WARN_ON(fbit >= 64);
> > +
> > + uc_priv->features |= BIT_ULL(fbit);
> > +}
> > +
> > +/**
> > + * __virtio_clear_bit - helper to clear feature bits
> > + *
> > + * For use by transports.
> > + *
> > + * @vdev: the transport device
> > + * @fbit: the feature bit
> > + */
> > +static inline void __virtio_clear_bit(struct udevice *udev, unsigned int fbit)
> > +{
> > + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
> > +
> > + /* Did you forget to fix assumptions on max features? */
> > + if (__builtin_constant_p(fbit))
> > + BUILD_BUG_ON(fbit >= 64);
> > + else
> > + WARN_ON(fbit >= 64);
> > +
> > + uc_priv->features &= ~BIT_ULL(fbit);
> > +}
> > +
> > +/**
> > + * virtio_has_feature - helper to determine if this device has this feature
> > + *
> > + * Note this API is only usable after the virtio device driver's bind phase,
> > + * as the feature has been negotiated between the device and the driver.
> > + *
> > + * @vdev: the virtio device
> > + * @fbit: the feature bit
> > + */
> > +static inline bool virtio_has_feature(struct udevice *vdev, unsigned int fbit)
> > +{
> > + if (!(vdev->flags & DM_FLAG_BOUND))
> > + WARN_ON(true);
> > +
> > + return __virtio_test_bit(vdev->parent, fbit);
> > +}
> > +
> > +static inline bool virtio_legacy_is_little_endian(void)
> > +{
> > +#ifdef __LITTLE_ENDIAN
> > + return true;
> > +#else
> > + return false;
> > +#endif
> > +}
> > +
> > +static inline bool virtio_is_little_endian(struct udevice *vdev)
> > +{
> > + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
> > +
> > + return !uc_priv->legacy || virtio_legacy_is_little_endian();
> > +}
> > +
> > +/* Memory accessors */
> > +static inline u16 virtio16_to_cpu(struct udevice *vdev, __virtio16 val)
> > +{
> > + return __virtio16_to_cpu(virtio_is_little_endian(vdev), val);
> > +}
> > +
> > +static inline __virtio16 cpu_to_virtio16(struct udevice *vdev, u16 val)
> > +{
> > + return __cpu_to_virtio16(virtio_is_little_endian(vdev), val);
> > +}
> > +
> > +static inline u32 virtio32_to_cpu(struct udevice *vdev, __virtio32 val)
> > +{
> > + return __virtio32_to_cpu(virtio_is_little_endian(vdev), val);
> > +}
> > +
> > +static inline __virtio32 cpu_to_virtio32(struct udevice *vdev, u32 val)
> > +{
> > + return __cpu_to_virtio32(virtio_is_little_endian(vdev), val);
> > +}
> > +
> > +static inline u64 virtio64_to_cpu(struct udevice *vdev, __virtio64 val)
> > +{
> > + return __virtio64_to_cpu(virtio_is_little_endian(vdev), val);
> > +}
> > +
> > +static inline __virtio64 cpu_to_virtio64(struct udevice *vdev, u64 val)
> > +{
> > + return __cpu_to_virtio64(virtio_is_little_endian(vdev), val);
> > +}
> > +
> > +/* Read @count fields, @bytes each */
> > +static inline void __virtio_cread_many(struct udevice *vdev,
> > + unsigned int offset,
> > + void *buf, size_t count, size_t bytes)
> > +{
> > + u32 old, gen;
> > + int i;
> > +
> > + virtio_generation(vdev, &gen);
>
> Error check?
>
In fact this ops can be optional. Will add a comment in v2.
> Should be in the uclass C file I think
>
> > + do {
> > + old = gen;
> > +
> > + for (i = 0; i < count; i++)
> > + virtio_get_config(vdev, offset + bytes * i,
> > + buf + i * bytes, bytes);
> > +
> > + virtio_generation(vdev, &gen);
> > + } while (gen != old);
> > +}
> > +
> > +static inline void virtio_cread_bytes(struct udevice *vdev,
> > + unsigned int offset,
> > + void *buf, size_t len)
> > +{
> > + __virtio_cread_many(vdev, offset, buf, len, 1);
> > +}
> > +
> > +static inline u8 virtio_cread8(struct udevice *vdev, unsigned int offset)
> > +{
> > + u8 ret;
> > +
> > + virtio_get_config(vdev, offset, &ret, sizeof(ret));
> > + return ret;
> > +}
> > +
> > +static inline void virtio_cwrite8(struct udevice *vdev,
> > + unsigned int offset, u8 val)
> > +{
> > + virtio_set_config(vdev, offset, &val, sizeof(val));
> > +}
> > +
> > +static inline u16 virtio_cread16(struct udevice *vdev,
> > + unsigned int offset)
> > +{
> > + u16 ret;
> > +
> > + virtio_get_config(vdev, offset, &ret, sizeof(ret));
> > + return virtio16_to_cpu(vdev, (__force __virtio16)ret);
> > +}
> > +
> > +static inline void virtio_cwrite16(struct udevice *vdev,
> > + unsigned int offset, u16 val)
> > +{
> > + val = (__force u16)cpu_to_virtio16(vdev, val);
> > + virtio_set_config(vdev, offset, &val, sizeof(val));
> > +}
> > +
> > +static inline u32 virtio_cread32(struct udevice *vdev,
> > + unsigned int offset)
> > +{
> > + u32 ret;
> > +
> > + virtio_get_config(vdev, offset, &ret, sizeof(ret));
> > + return virtio32_to_cpu(vdev, (__force __virtio32)ret);
> > +}
> > +
> > +static inline void virtio_cwrite32(struct udevice *vdev,
> > + unsigned int offset, u32 val)
> > +{
> > + val = (__force u32)cpu_to_virtio32(vdev, val);
> > + virtio_set_config(vdev, offset, &val, sizeof(val));
> > +}
> > +
> > +static inline u64 virtio_cread64(struct udevice *vdev,
> > + unsigned int offset)
> > +{
> > + u64 ret;
> > +
> > + __virtio_cread_many(vdev, offset, &ret, 1, sizeof(ret));
> > + return virtio64_to_cpu(vdev, (__force __virtio64)ret);
> > +}
> > +
> > +static inline void virtio_cwrite64(struct udevice *vdev,
> > + unsigned int offset, u64 val)
> > +{
> > + val = (__force u64)cpu_to_virtio64(vdev, val);
> > + virtio_set_config(vdev, offset, &val, sizeof(val));
> > +}
> > +
> > +/* Config space read accessor */
> > +#define virtio_cread(vdev, structname, member, ptr) \
> > + do { \
> > + /* Must match the member's type, and be integer */ \
> > + if (!typecheck(typeof((((structname *)0)->member)), *(ptr))) \
> > + (*ptr) = 1; \
> > + \
> > + switch (sizeof(*ptr)) { \
> > + case 1: \
> > + *(ptr) = virtio_cread8(vdev, \
> > + offsetof(structname, member)); \
> > + break; \
> > + case 2: \
> > + *(ptr) = virtio_cread16(vdev, \
> > + offsetof(structname, member)); \
> > + break; \
> > + case 4: \
> > + *(ptr) = virtio_cread32(vdev, \
> > + offsetof(structname, member)); \
> > + break; \
> > + case 8: \
> > + *(ptr) = virtio_cread64(vdev, \
> > + offsetof(structname, member)); \
> > + break; \
> > + default: \
> > + WARN_ON(true); \
> > + } \
> > + } while (0)
> > +
> > +/* Config space write accessor */
> > +#define virtio_cwrite(vdev, structname, member, ptr) \
> > + do { \
> > + /* Must match the member's type, and be integer */ \
> > + if (!typecheck(typeof((((structname *)0)->member)), *(ptr))) \
> > + WARN_ON((*ptr) == 1); \
> > + \
> > + switch (sizeof(*ptr)) { \
> > + case 1: \
> > + virtio_cwrite8(vdev, \
> > + offsetof(structname, member), \
> > + *(ptr)); \
> > + break; \
> > + case 2: \
> > + virtio_cwrite16(vdev, \
> > + offsetof(structname, member), \
> > + *(ptr)); \
> > + break; \
> > + case 4: \
> > + virtio_cwrite32(vdev, \
> > + offsetof(structname, member), \
> > + *(ptr)); \
> > + break; \
> > + case 8: \
> > + virtio_cwrite64(vdev, \
> > + offsetof(structname, member), \
> > + *(ptr)); \
> > + break; \
> > + default: \
> > + WARN_ON(true); \
> > + } \
> > + } while (0)
> > +
> > +/* Conditional config space accessors */
> > +#define virtio_cread_feature(vdev, fbit, structname, member, ptr) \
> > + ({ \
> > + int _r = 0; \
> > + if (!virtio_has_feature(vdev, fbit)) \
> > + _r = -ENOENT; \
> > + else \
> > + virtio_cread(vdev, structname, member, ptr); \
> > + _r; \
> > + })
> > +
> > +#endif /* __VIRTIO_H__ */
> > diff --git a/include/virtio_types.h b/include/virtio_types.h
> > new file mode 100644
> > index 0000000..d700d19
> > --- /dev/null
> > +++ b/include/virtio_types.h
> > @@ -0,0 +1,24 @@
> > +/* SPDX-License-Identifier: BSD-3-Clause */
> > +/*
> > + * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > + * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> > + *
> > + * From Linux kernel include/uapi/linux/virtio_types.h
> > + */
> > +
> > +#ifndef _LINUX_VIRTIO_TYPES_H
> > +#define _LINUX_VIRTIO_TYPES_H
> > +
> > +#include <linux/types.h>
> > +
> > +/*
> > + * __virtio{16,32,64} have the following meaning:
> > + * - __u{16,32,64} for virtio devices in legacy mode, accessed in native endian
> > + * - __le{16,32,64} for standard-compliant virtio devices
> > + */
> > +
> > +typedef __u16 __bitwise __virtio16;
> > +typedef __u32 __bitwise __virtio32;
> > +typedef __u64 __bitwise __virtio64;
> > +
> > +#endif /* _LINUX_VIRTIO_TYPES_H */
> > --
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices
2018-09-27 22:10 ` Tuomas Tynkkynen
@ 2018-10-11 9:09 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-11 9:09 UTC (permalink / raw)
To: u-boot
Hi Tuomas,
On Fri, Sep 28, 2018 at 6:10 AM Tuomas Tynkkynen
<tuomas.tynkkynen@iki.fi> wrote:
>
> Hi Bin,
>
> Thanks for the patches, they look great. Some minor comments:
>
> On 09/23/2018 04:42 PM, Bin Meng wrote:
> > This adds a new virtio uclass driver for “virtio” [1] family of
> > devices that are are found in virtual environments like QEMU,
> > yet by design they look like physical devices to the guest.
> >
> > The uclass driver provides child_pre_probe() and child_post_probe()
> > methods to do some common operations for virtio device drivers like
> > device and driver supported feature negotiation, etc.
> >
> > [1] http://docs.oasis-open.org/virtio/virtio/v1.0/virtio-v1.0.pdf
> >
> > Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---...
> >+
> >+config VIRTIO
> >+ bool
> >+ help
> >+ This option is selected by any driver which implements the virtio
> >+ bus, such as CONFIG_VIRTIO_MMIO or CONFIG_VIRTIO_PCI.
>
> I think most other places use the term 'transport' over 'bus'.
>
Changed in v2.
> > +
> > +int virtio_get_config(struct udevice *vdev, unsigned int offset,
> > + void *buf, unsigned int len)
> > +{
> > + struct dm_virtio_ops *ops;
> > +
> > + ops = virtio_get_ops(vdev->parent);
> > + if (!ops->get_config)
> > + return -ENOSYS;
>
> I'm not sure how useful the -ENOSYS fallbacks for most of these ops
> are. E.g. a transport lacking .find_vqs() cannot ever be useful
> for implementing real-world devices.
>
Agreed. Address this in v2.
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management
2018-09-27 13:42 ` Simon Glass
@ 2018-10-11 9:50 ` Bin Meng
2018-10-12 0:00 ` Simon Glass
0 siblings, 1 reply; 82+ messages in thread
From: Bin Meng @ 2018-10-11 9:50 UTC (permalink / raw)
To: u-boot
Hi Simon,
On Thu, Sep 27, 2018 at 9:42 PM Simon Glass <sjg@chromium.org> wrote:
>
> On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> > From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> >
> > This adds support for managing virtual queue/ring, the channel
> > for high performance I/O between host and guest.
> >
> > Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> >
> > drivers/virtio/Makefile | 2 +-
> > drivers/virtio/virtio_ring.c | 356 +++++++++++++++++++++++++++++++++++++++++++
> > include/virtio_ring.h | 320 ++++++++++++++++++++++++++++++++++++++
> > 3 files changed, 677 insertions(+), 1 deletion(-)
> > create mode 100644 drivers/virtio/virtio_ring.c
> > create mode 100644 include/virtio_ring.h
>
> Seems like vring_create_virtqueue() should return an error code rather
> than a pointer?
I think NULL as a pointer can be a sign for the error.
>
> Reviewed-by: Simon Glass <sjg@chromium.org>
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot
2018-09-27 13:42 ` Simon Glass
@ 2018-10-11 13:21 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-11 13:21 UTC (permalink / raw)
To: u-boot
Hi Simon,
On Thu, Sep 27, 2018 at 9:43 PM Simon Glass <sjg@chromium.org> wrote:
>
> On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> > Currently devices on the virtio bus is not automatically enumerated,
> > which means peripherals on the virtio bus are not discovered by their
> > drivers. This uses board_init() to do the virtio enumeration.
> >
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> >
> > board/emulation/qemu-arm/Kconfig | 3 +++
> > board/emulation/qemu-arm/qemu-arm.c | 7 +++++++
> > 2 files changed, 10 insertions(+)
> >
>
> Reviewed-by: Simon Glass <sjg@chromium.org>
>
> But I wonder if we should have a flag in the uclass or perhaps device
> tree, to indicate that all devices in it should be probed at start-up?
> Could be useful for PCI too.
>
I think that's a good idea. I will leave this for now and when we have
that capability we can revisit.
[snip]
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot
2018-09-27 22:13 ` Tuomas Tynkkynen
@ 2018-10-11 13:28 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-11 13:28 UTC (permalink / raw)
To: u-boot
Hi Tuomas,
On Fri, Sep 28, 2018 at 6:13 AM Tuomas Tynkkynen
<tuomas.tynkkynen@iki.fi> wrote:
>
> Hi Bin,
>
> On 09/23/2018 04:42 PM, Bin Meng wrote:
> > Currently devices on the virtio bus is not automatically enumerated,
> > which means peripherals on the virtio bus are not discovered by their
> > drivers. This uses board_init() to do the virtio enumeration.
> >
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> >
> > board/emulation/qemu-arm/Kconfig | 3 +++
> > board/emulation/qemu-arm/qemu-arm.c | 7 +++++++
> > 2 files changed, 10 insertions(+)
> >
> ...
> >diff --git a/board/emulation/qemu-arm/Kconfig b/board/emulation/qemu-arm/Kconfig
> >index d1c08c2..16b80fe 100644
> >--- a/board/emulation/qemu-arm/Kconfig
> >+++ b/board/emulation/qemu-arm/Kconfig
> >@@ -5,5 +5,8 @@ config SYS_TEXT_BASE
> >
> > config BOARD_SPECIFIC_OPTIONS # dummy
> > def_bool y
> >+ imply VIRTIO_MMIO
> >+ imply VIRTIO_NET
> >+ imply VIRTIO_BLK
>
> I think we should have VIRTIO_PCI here as well, so that QEMU command lines
> that work on x86 will work on ARM just as well.
>
Will do in v2.
> ...
> > --- a/board/emulation/qemu-arm/qemu-arm.c
> > +++ b/board/emulation/qemu-arm/qemu-arm.c
> > @@ -4,6 +4,7 @@
> > */
> > #include <common.h>
> > #include <fdtdec.h>
> > +#include <virtio.h>
> >
> > #ifdef CONFIG_ARM64
> > #include <asm/armv8/mmu.h>
> > @@ -58,6 +59,12 @@ struct mm_region *mem_map = qemu_arm64_mem_map;
> >
> > int board_init(void)
> > {
> > + /*
> > + * Make sure virtio bus is enumerated so that peripherals
> > + * on the virtio bus can be discovered by their drivers
> > + */
> > + virtio_init();
> > +
> > return 0;
> > }
> >
> >
>
> Note that in include/configs/qemu-arm.h, the boards auto-enumerate
> PCI devices with a different mechanism, like this:
>
> #define CONFIG_PREBOOT "pci enum"
>
> I am not sure which one is better but at least we should be consistent.
Ah yes, but I felt the same as you about which one is better :). I
think using PREBOOT is a little bit late, for example if we call
"virtio scan" here, we still see "Net: No ethernet found." which may
confuse people. Probably what Simon suggested (have a flag to indicate
that all devices in it should be probed at start-up) is an ideal
solution ...
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 20/27] x86: Implement arch-specific io accessor routines
2018-09-27 13:42 ` Simon Glass
@ 2018-10-11 13:33 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-11 13:33 UTC (permalink / raw)
To: u-boot
Hi Simon,
On Thu, Sep 27, 2018 at 9:43 PM Simon Glass <sjg@chromium.org> wrote:
>
> On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> > At present the generic io{read,write}{8,16,32} routines only support
> > MMIO access. With architecture like x86 that has a separate IO space,
> > these routines cannot be used to access I/O ports.
> >
> > Implement x86-specific version to support both PIO and MMIO access,
> > so that drivers for multiple architectures can use these accessors
> > without the need to know whether it's MMIO or PIO.
> >
> > These are ported from Linux kernel lib/iomap.c, with slight changes.
> >
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> >
> > arch/Kconfig | 1 +
> > arch/x86/include/asm/io.h | 66 +++++++++++++++++++++++++++++++++++++++++++++++
> > 2 files changed, 67 insertions(+)
>
> Reviewed-by: Simon Glass <sjg@chromium.org>
>
> Should we use regmap instead?
No, regmap is for something else, e.g. the same driver to be used on
different buses.
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 21/27] virtio: Add virtio over pci transport driver
2018-09-27 13:42 ` Simon Glass
@ 2018-10-11 13:39 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-11 13:39 UTC (permalink / raw)
To: u-boot
Hi Simon,
On Thu, Sep 27, 2018 at 9:43 PM Simon Glass <sjg@chromium.org> wrote:
>
> Hi Bin,
>
> On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> > This adds a transport driver that implements UCLASS_VIRTIO for
> > virtio over pci, which is commonly used on x86.
> >
> > It only supports the legacy interface of the pci transport, which
> > is the default device that QEMU emulates.
> >
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> >
> > drivers/virtio/Kconfig | 8 +
> > drivers/virtio/Makefile | 1 +
> > drivers/virtio/virtio_pci.c | 420 ++++++++++++++++++++++++++++++++++++++++++++
> > drivers/virtio/virtio_pci.h | 173 ++++++++++++++++++
> > 4 files changed, 602 insertions(+)
> > create mode 100644 drivers/virtio/virtio_pci.c
> > create mode 100644 drivers/virtio/virtio_pci.h
>
> Reviewed-by: Simon Glass <sjg@chromium.org>
>
> vring_create_virtqueue() should return an error I think - you assume -ENOMEM
>
It returns a NULL pointer and the error is -ENOMEM, which will be
checked by the caller via IS_ERR()
> That is a huge table of PCI devices. Can you use a class instead?
Unfortunately we can't. The virtio spec does not define a dedicated class.
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 25/27] virtio: pci: Support non-legacy PCI transport device
2018-09-27 13:42 ` Simon Glass
@ 2018-10-11 13:41 ` Bin Meng
0 siblings, 0 replies; 82+ messages in thread
From: Bin Meng @ 2018-10-11 13:41 UTC (permalink / raw)
To: u-boot
Hi Simon,
On Thu, Sep 27, 2018 at 9:43 PM Simon Glass <sjg@chromium.org> wrote:
>
> On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
> > By default QEMU creates legacy PCI transport devices, but we can
> > ask QEMU to create non-legacy one if we pass additional device
> > property/value pairs in the command line:
> >
> > -device virtio-blk-pci,disable-legacy=true,disable-modern=false
> >
> > This adds a new driver driver to support non-legacy (modern) device
> > mode. Previous driver/file name is changed accordingly.
> >
> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> > ---
> >
> > drivers/virtio/Makefile | 2 +-
> > .../virtio/{virtio_pci.c => virtio_pci_legacy.c} | 6 +-
> > drivers/virtio/virtio_pci_modern.c | 612 +++++++++++++++++++++
> > 3 files changed, 616 insertions(+), 4 deletions(-)
> > rename drivers/virtio/{virtio_pci.c => virtio_pci_legacy.c} (98%)
> > create mode 100644 drivers/virtio/virtio_pci_modern.c
>
> Reviewed-by: Simon Glass <sjg@chromium.org>
>
> Isn't there some common code between the two?
Unfortunately the legacy and modern PCI devices are quite different,
so we have to use 2 drivers which is how Linux does. For the
virtio-mmio driver, the difference are not that big so we can use one
driver to support both.
Regards,
Bin
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management
2018-10-11 9:50 ` Bin Meng
@ 2018-10-12 0:00 ` Simon Glass
0 siblings, 0 replies; 82+ messages in thread
From: Simon Glass @ 2018-10-12 0:00 UTC (permalink / raw)
To: u-boot
Hi Bin,
On 11 October 2018 at 03:50, Bin Meng <bmeng.cn@gmail.com> wrote:
> Hi Simon,
>
> On Thu, Sep 27, 2018 at 9:42 PM Simon Glass <sjg@chromium.org> wrote:
>>
>> On 23 September 2018 at 06:42, Bin Meng <bmeng.cn@gmail.com> wrote:
>> > From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>> >
>> > This adds support for managing virtual queue/ring, the channel
>> > for high performance I/O between host and guest.
>> >
>> > Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>> > Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
>> > ---
>> >
>> > drivers/virtio/Makefile | 2 +-
>> > drivers/virtio/virtio_ring.c | 356 +++++++++++++++++++++++++++++++++++++++++++
>> > include/virtio_ring.h | 320 ++++++++++++++++++++++++++++++++++++++
>> > 3 files changed, 677 insertions(+), 1 deletion(-)
>> > create mode 100644 drivers/virtio/virtio_ring.c
>> > create mode 100644 include/virtio_ring.h
>>
>> Seems like vring_create_virtqueue() should return an error code rather
>> than a pointer?
>
> I think NULL as a pointer can be a sign for the error.
Yes but the issue here is that it returns more than one error, so an
in is easier. With NULL you don't know what went wrong. There is
ERR_PTR of course.
Regards,
Simon
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 26/27] virtio: net: Support non-legacy device
2018-09-23 13:42 ` [U-Boot] [PATCH 26/27] virtio: net: Support non-legacy device Bin Meng
2018-09-27 13:43 ` Simon Glass
@ 2018-10-15 21:59 ` Joe Hershberger
1 sibling, 0 replies; 82+ messages in thread
From: Joe Hershberger @ 2018-10-15 21:59 UTC (permalink / raw)
To: u-boot
On Sun, Sep 23, 2018 at 8:58 AM Bin Meng <bmeng.cn@gmail.com> wrote:
>
> For v1.0 compliant device, it always assumes the member 'num_buffers'
> exists in the struct virtio_net_hdr while the legacy driver only
> presented 'num_buffers' when VIRTIO_NET_F_MRG_RXBUF was negotiated.
> Without that feature the structure was 2 bytes shorter.
>
> Update the driver to support the non-legacy device.
>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
Acked-by: Joe Hershberger <joe.hershberger@ni.com>
^ permalink raw reply [flat|nested] 82+ messages in thread
* [U-Boot] [PATCH 05/27] virtio: Add net driver support
2018-09-23 13:42 ` [U-Boot] [PATCH 05/27] virtio: Add net driver support Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-27 22:12 ` Tuomas Tynkkynen
@ 2018-10-22 23:09 ` Joe Hershberger
2 siblings, 0 replies; 82+ messages in thread
From: Joe Hershberger @ 2018-10-22 23:09 UTC (permalink / raw)
To: u-boot
On Sun, Sep 23, 2018 at 8:48 AM Bin Meng <bmeng.cn@gmail.com> wrote:
>
> From: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
>
> This adds virtio net device driver support.
>
> Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
> ---
>
> drivers/virtio/Kconfig | 7 ++
> drivers/virtio/Makefile | 1 +
> drivers/virtio/virtio_net.c | 215 +++++++++++++++++++++++++++++++++++
> drivers/virtio/virtio_net.h | 268 ++++++++++++++++++++++++++++++++++++++++++++
> 4 files changed, 491 insertions(+)
> create mode 100644 drivers/virtio/virtio_net.c
> create mode 100644 drivers/virtio/virtio_net.h
>
> diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
> index 60cfaf8..ceea03a 100644
> --- a/drivers/virtio/Kconfig
> +++ b/drivers/virtio/Kconfig
> @@ -18,4 +18,11 @@ config VIRTIO_MMIO
> This driver provides support for memory mapped virtio
> platform device driver.
>
> +config VIRTIO_NET
> + bool "virtio net driver"
> + depends on VIRTIO
> + help
> + This is the virtual net driver for virtio. It can be used with
> + QEMU based targets.
> +
> endmenu
> diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
> index 2e48785..b7764f1 100644
> --- a/drivers/virtio/Makefile
> +++ b/drivers/virtio/Makefile
> @@ -5,3 +5,4 @@
>
> obj-y += virtio-uclass.o virtio_ring.o
> obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o
> +obj-$(CONFIG_VIRTIO_NET) += virtio_net.o
> diff --git a/drivers/virtio/virtio_net.c b/drivers/virtio/virtio_net.c
> new file mode 100644
> index 0000000..1ab1513
> --- /dev/null
> +++ b/drivers/virtio/virtio_net.c
> @@ -0,0 +1,215 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> + * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> + */
> +
> +#include <common.h>
> +#include <dm.h>
> +#include <net.h>
> +#include <virtio.h>
> +#include <virtio_ring.h>
> +#include "virtio_net.h"
> +
> +/* Amount of buffers to keep in the RX virtqueue */
> +#define VIRTIO_NET_NUM_RX_BUFS 32
> +
> +/*
> + * This value comes from the VirtIO spec: 1500 for maximum packet size,
> + * 14 for the Ethernet header, 12 for virtio_net_hdr. In total 1526 bytes.
> + */
> +#define VIRTIO_NET_RX_BUF_SIZE 1526
> +
> +struct virtio_net_priv {
> + union {
> + struct virtqueue *vqs[2];
> + struct {
> + struct virtqueue *rx_vq;
> + struct virtqueue *tx_vq;
> + };
> + };
> +
> + char rx_buff[VIRTIO_NET_NUM_RX_BUFS][VIRTIO_NET_RX_BUF_SIZE];
> + bool rx_running;
> +};
> +
> +/*
> + * For simplicity, the driver only negotiates the VIRTIO_NET_F_MAC feature.
> + * For the VIRTIO_NET_F_STATUS feature, we don't negotiate it, hence per spec
> + * we should assume the link is always active.
> + */
> +static u32 feature[] = {
> + VIRTIO_NET_F_MAC
> +};
> +
> +static u32 feature_legacy[] = {
> + VIRTIO_NET_F_MAC
> +};
> +
> +static int virtio_net_start(struct udevice *dev)
> +{
> + struct virtio_net_priv *priv = dev_get_priv(dev);
> + struct virtio_sg sg;
> + struct virtio_sg *sgs[] = { &sg };
> + int i;
> +
> + if (!priv->rx_running) {
> + /* receive buffer length is always 1526 */
> + sg.length = VIRTIO_NET_RX_BUF_SIZE;
> +
> + /* setup the receive buffer address */
> + for (i = 0; i < VIRTIO_NET_NUM_RX_BUFS; i++) {
> + sg.addr = priv->rx_buff[i];
It's kinda peculiar the way this is used in place multiple times.
> + virtqueue_add(priv->rx_vq, sgs, 0, 1);
I hope this copies the structure since it is stack memory and modified
on each iteration. Probably justifies a comment.
> + }
> +
> + virtqueue_kick(priv->rx_vq);
> +
> + /* setup the receive queue only once */
> + priv->rx_running = true;
> + }
> +
> + return 0;
> +}
> +
> +static int virtio_net_send(struct udevice *dev, void *packet, int length)
> +{
> + struct virtio_net_priv *priv = dev_get_priv(dev);
> + struct virtio_net_hdr hdr;
> + struct virtio_sg hdr_sg = { &hdr, sizeof(hdr) };
> + struct virtio_sg data_sg = { packet, length };
> + struct virtio_sg *sgs[] = { &hdr_sg, &data_sg };
> + int ret;
> +
> + memset(&hdr, 0, sizeof(struct virtio_net_hdr));
> +
> + ret = virtqueue_add(priv->tx_vq, sgs, 2, 0);
> + if (ret)
> + return ret;
> +
> + virtqueue_kick(priv->tx_vq);
> +
> + while (1) {
> + if (virtqueue_get_buf(priv->tx_vq, NULL))
> + break;
Potential infinite loop?
> + }
> +
> + return 0;
> +}
> +
> +static int virtio_net_recv(struct udevice *dev, int flags, uchar **packetp)
> +{
> + struct virtio_net_priv *priv = dev_get_priv(dev);
> + unsigned int len;
> + void *buf;
> +
> + buf = virtqueue_get_buf(priv->rx_vq, &len);
> + if (!buf)
> + return -EAGAIN;
> +
> + *packetp = buf + sizeof(struct virtio_net_hdr);
> + return len - sizeof(struct virtio_net_hdr);
> +}
> +
> +static int virtio_net_free_pkt(struct udevice *dev, uchar *packet, int length)
> +{
> + struct virtio_net_priv *priv = dev_get_priv(dev);
> + void *buf = packet - sizeof(struct virtio_net_hdr);
> + struct virtio_sg sg = { buf, VIRTIO_NET_RX_BUF_SIZE };
> + struct virtio_sg *sgs[] = { &sg };
> +
> + /* Put the buffer back to the rx ring */
> + virtqueue_add(priv->rx_vq, sgs, 0, 1);
So does that mean that the virtqueue_get_buf() function removed it?
> +
> + return 0;
> +}
> +
> +static void virtio_net_stop(struct udevice *dev)
> +{
> + /*
> + * There is no way to stop the queue from running, unless we issue
> + * a reset to the virtio device, and re-do the queue initialization
> + * from the beginning.
> + */
> +}
> +
> +static int virtio_net_write_hwaddr(struct udevice *dev)
> +{
> + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(dev->parent);
> + struct eth_pdata *pdata = dev_get_platdata(dev);
> + int i;
> +
> + /*
> + * v1.0 compliant device's MAC address is set through control channel,
> + * which we don't support for now.
> + */
> + if (!uc_priv->legacy)
> + return -ENOSYS;
> +
> + for (i = 0; i < sizeof(pdata->enetaddr); i++) {
> + virtio_cwrite8(dev,
> + offsetof(struct virtio_net_config, mac) + i,
> + pdata->enetaddr[i]);
> + }
> +
> + return 0;
> +}
> +
> +static int virtio_net_read_rom_hwaddr(struct udevice *dev)
> +{
> + struct eth_pdata *pdata = dev_get_platdata(dev);
> +
> + if (!pdata)
> + return -ENOSYS;
> +
> + if (virtio_has_feature(dev, VIRTIO_NET_F_MAC)) {
> + virtio_cread_bytes(dev,
> + offsetof(struct virtio_net_config, mac),
> + pdata->enetaddr, sizeof(pdata->enetaddr));
> + }
> +
> + return 0;
> +}
> +
> +static int virtio_net_bind(struct udevice *dev)
> +{
> + struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(dev->parent);
> +
> + /* Indicate what driver features we support */
> + virtio_driver_features_init(uc_priv, feature, ARRAY_SIZE(feature),
> + feature_legacy, ARRAY_SIZE(feature_legacy));
> +
> + return 0;
> +}
> +
> +static int virtio_net_probe(struct udevice *dev)
> +{
> + struct virtio_net_priv *priv = dev_get_priv(dev);
> + int ret;
> +
Seems like priv->rx_running should be initialized to false here.
> + ret = virtio_find_vqs(dev, 2, priv->vqs);
> + if (ret < 0)
> + return ret;
> +
> + return 0;
> +}
> +
> +static const struct eth_ops virtio_net_ops = {
> + .start = virtio_net_start,
> + .send = virtio_net_send,
> + .recv = virtio_net_recv,
> + .free_pkt = virtio_net_free_pkt,
> + .stop = virtio_net_stop,
> + .write_hwaddr = virtio_net_write_hwaddr,
> + .read_rom_hwaddr = virtio_net_read_rom_hwaddr,
> +};
> +
> +U_BOOT_DRIVER(virtio_net) = {
> + .name = VIRTIO_NET_DRV_NAME,
> + .id = UCLASS_ETH,
> + .bind = virtio_net_bind,
> + .probe = virtio_net_probe,
> + .ops = &virtio_net_ops,
> + .priv_auto_alloc_size = sizeof(struct virtio_net_priv),
> + .platdata_auto_alloc_size = sizeof(struct eth_pdata),
> +};
> diff --git a/drivers/virtio/virtio_net.h b/drivers/virtio/virtio_net.h
> new file mode 100644
> index 0000000..c92bae5
> --- /dev/null
> +++ b/drivers/virtio/virtio_net.h
> @@ -0,0 +1,268 @@
> +/* SPDX-License-Identifier: BSD-3-Clause */
> +/*
> + * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
> + * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
> + *
> + * From Linux kernel include/uapi/linux/virtio_net.h
> + */
> +
> +#ifndef _LINUX_VIRTIO_NET_H
> +#define _LINUX_VIRTIO_NET_H
> +
> +/* TODO: needs to be removed! */
> +#define ETH_ALEN 6
> +
> +/* The feature bitmap for virtio net */
> +
> +/* Host handles pkts w/ partial csum */
> +#define VIRTIO_NET_F_CSUM 0
> +/* Guest handles pkts w/ partial csum */
> +#define VIRTIO_NET_F_GUEST_CSUM 1
> +/* Dynamic offload configuration */
> +#define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 2
> +/* Initial MTU advice */
> +#define VIRTIO_NET_F_MTU 3
> +/* Host has given MAC address */
> +#define VIRTIO_NET_F_MAC 5
> +/* Guest can handle TSOv4 in */
> +#define VIRTIO_NET_F_GUEST_TSO4 7
> +/* Guest can handle TSOv6 in */
> +#define VIRTIO_NET_F_GUEST_TSO6 8
> +/* Guest can handle TSO[6] w/ ECN in */
> +#define VIRTIO_NET_F_GUEST_ECN 9
> +/* Guest can handle UFO in */
> +#define VIRTIO_NET_F_GUEST_UFO 10
> +/* Host can handle TSOv4 in */
> +#define VIRTIO_NET_F_HOST_TSO4 11
> +/* Host can handle TSOv6 in */
> +#define VIRTIO_NET_F_HOST_TSO6 12
> +/* Host can handle TSO[6] w/ ECN in */
> +#define VIRTIO_NET_F_HOST_ECN 13
> +/* Host can handle UFO in */
> +#define VIRTIO_NET_F_HOST_UFO 14
> +/* Host can merge receive buffers */
> +#define VIRTIO_NET_F_MRG_RXBUF 15
> +/* virtio_net_config.status available */
> +#define VIRTIO_NET_F_STATUS 16
> +/* Control channel available */
> +#define VIRTIO_NET_F_CTRL_VQ 17
> +/* Control channel RX mode support */
> +#define VIRTIO_NET_F_CTRL_RX 18
> +/* Control channel VLAN filtering */
> +#define VIRTIO_NET_F_CTRL_VLAN 19
> +/* Extra RX mode control support */
> +#define VIRTIO_NET_F_CTRL_RX_EXTRA 20
> +/* Guest can announce device on the network */
> +#define VIRTIO_NET_F_GUEST_ANNOUNCE 21
> +/* Device supports receive flow steering */
> +#define VIRTIO_NET_F_MQ 22
> +/* Set MAC address */
> +#define VIRTIO_NET_F_CTRL_MAC_ADDR 23
> +/* Device set linkspeed and duplex */
> +#define VIRTIO_NET_F_SPEED_DUPLEX 63
> +
> +#ifndef VIRTIO_NET_NO_LEGACY
> +/* Host handles pkts w/ any GSO type */
> +#define VIRTIO_NET_F_GSO 6
> +#endif /* VIRTIO_NET_NO_LEGACY */
> +
> +#define VIRTIO_NET_S_LINK_UP 1 /* Link is up */
> +#define VIRTIO_NET_S_ANNOUNCE 2 /* Announcement is needed */
> +
> +struct __packed virtio_net_config {
> + /* The config defining mac address (if VIRTIO_NET_F_MAC) */
> + __u8 mac[ETH_ALEN];
> + /* See VIRTIO_NET_F_STATUS and VIRTIO_NET_S_* above */
> + __u16 status;
> + /*
> + * Maximum number of each of transmit and receive queues;
> + * see VIRTIO_NET_F_MQ and VIRTIO_NET_CTRL_MQ.
> + * Legal values are between 1 and 0x8000
> + */
> + __u16 max_virtqueue_pairs;
> + /* Default maximum transmit unit advice */
> + __u16 mtu;
> + /*
> + * speed, in units of 1Mb. All values 0 to INT_MAX are legal.
> + * Any other value stands for unknown.
> + */
> + __u32 speed;
> + /*
> + * 0x00 - half duplex
> + * 0x01 - full duplex
> + * Any other value stands for unknown.
> + */
> + __u8 duplex;
> +};
> +
> +/*
> + * This header comes first in the scatter-gather list. If you don't
> + * specify GSO or CSUM features, you can simply ignore the header.
> + *
> + * This is bitwise-equivalent to the legacy struct virtio_net_hdr_mrg_rxbuf,
> + * only flattened.
> + */
> +struct virtio_net_hdr_v1 {
> +#define VIRTIO_NET_HDR_F_NEEDS_CSUM 0x01 /* Use csum_start, csum_offset */
> +#define VIRTIO_NET_HDR_F_DATA_VALID 0x02 /* Csum is valid */
> + __u8 flags;
> +#define VIRTIO_NET_HDR_GSO_NONE 0x00 /* Not a GSO frame */
> +#define VIRTIO_NET_HDR_GSO_TCPV4 0x01 /* GSO frame, IPv4 TCP (TSO) */
> +#define VIRTIO_NET_HDR_GSO_UDP 0x03 /* GSO frame, IPv4 UDP (UFO) */
> +#define VIRTIO_NET_HDR_GSO_TCPV6 0x04 /* GSO frame, IPv6 TCP */
> +#define VIRTIO_NET_HDR_GSO_ECN 0x80 /* TCP has ECN set */
> + __u8 gso_type;
> + __virtio16 hdr_len; /* Ethernet + IP + tcp/udp hdrs */
> + __virtio16 gso_size; /* Bytes to append to hdr_len per frame */
> + __virtio16 csum_start; /* Position to start checksumming from */
> + __virtio16 csum_offset; /* Offset after that to place checksum */
> + __virtio16 num_buffers; /* Number of merged rx buffers */
> +};
> +
> +#ifndef VIRTIO_NET_NO_LEGACY
> +/*
> + * This header comes first in the scatter-gather list.
> + *
> + * For legacy virtio, if VIRTIO_F_ANY_LAYOUT is not negotiated, it must
> + * be the first element of the scatter-gather list. If you don't
> + * specify GSO or CSUM features, you can simply ignore the header.
> + */
> +struct virtio_net_hdr {
> + /* See VIRTIO_NET_HDR_F_* */
> + __u8 flags;
> + /* See VIRTIO_NET_HDR_GSO_* */
> + __u8 gso_type;
> + __virtio16 hdr_len; /* Ethernet + IP + tcp/udp hdrs */
> + __virtio16 gso_size; /* Bytes to append to hdr_len per frame */
> + __virtio16 csum_start; /* Position to start checksumming from */
> + __virtio16 csum_offset; /* Offset after that to place checksum */
> +};
> +
> +/*
> + * This is the version of the header to use when the MRG_RXBUF
> + * feature has been negotiated.
> + */
> +struct virtio_net_hdr_mrg_rxbuf {
> + struct virtio_net_hdr hdr;
> + __virtio16 num_buffers; /* Number of merged rx buffers */
> +};
> +#endif /* ...VIRTIO_NET_NO_LEGACY */
> +
> +/*
> + * Control virtqueue data structures
> + *
> + * The control virtqueue expects a header in the first sg entry
> + * and an ack/status response in the last entry. Data for the
> + * command goes in between.
> + */
> +struct __packed virtio_net_ctrl_hdr {
> + __u8 class;
> + __u8 cmd;
> +};
> +
> +typedef __u8 virtio_net_ctrl_ack;
> +
> +#define VIRTIO_NET_OK 0
> +#define VIRTIO_NET_ERR 1
> +
> +/*
> + * Control the RX mode, ie. promisucous, allmulti, etc...
> + *
> + * All commands require an "out" sg entry containing a 1 byte state value,
> + * zero = disable, non-zero = enable.
> + *
> + * Commands 0 and 1 are supported with the VIRTIO_NET_F_CTRL_RX feature.
> + * Commands 2-5 are added with VIRTIO_NET_F_CTRL_RX_EXTRA.
> + */
> +#define VIRTIO_NET_CTRL_RX 0
> +#define VIRTIO_NET_CTRL_RX_PROMISC 0
> +#define VIRTIO_NET_CTRL_RX_ALLMULTI 1
> +#define VIRTIO_NET_CTRL_RX_ALLUNI 2
> +#define VIRTIO_NET_CTRL_RX_NOMULTI 3
> +#define VIRTIO_NET_CTRL_RX_NOUNI 4
> +#define VIRTIO_NET_CTRL_RX_NOBCAST 5
> +
> +/*
> + * Control the MAC
> + *
> + * The MAC filter table is managed by the hypervisor, the guest should assume
> + * the size is infinite. Filtering should be considered non-perfect, ie. based
> + * on hypervisor resources, the guest may received packets from sources not
> + * specified in the filter list.
> + *
> + * In addition to the class/cmd header, the TABLE_SET command requires two
> + * out scatterlists. Each contains a 4 byte count of entries followed by a
> + * concatenated byte stream of the ETH_ALEN MAC addresses. The first sg list
> + * contains unicast addresses, the second is for multicast. This functionality
> + * is present if the VIRTIO_NET_F_CTRL_RX feature is available.
> + *
> + * The ADDR_SET command requests one out scatterlist, it contains a 6 bytes MAC
> + * address. This functionality is present if the VIRTIO_NET_F_CTRL_MAC_ADDR
> + * feature is available.
> + */
> +struct __packed virtio_net_ctrl_mac {
> + __virtio32 entries;
> + __u8 macs[][ETH_ALEN];
> +};
> +
> +#define VIRTIO_NET_CTRL_MAC 1
> +#define VIRTIO_NET_CTRL_MAC_TABLE_SET 0
> +#define VIRTIO_NET_CTRL_MAC_ADDR_SET 1
> +
> +/*
> + * Control VLAN filtering
> + *
> + * The VLAN filter table is controlled via a simple ADD/DEL interface. VLAN IDs
> + * not added may be filterd by the hypervisor. Del is the opposite of add. Both
> + * commands expect an out entry containing a 2 byte VLAN ID. VLAN filterting is
> + * available with the VIRTIO_NET_F_CTRL_VLAN feature bit.
> + */
> +#define VIRTIO_NET_CTRL_VLAN 2
> +#define VIRTIO_NET_CTRL_VLAN_ADD 0
> +#define VIRTIO_NET_CTRL_VLAN_DEL 1
> +
> +/*
> + * Control link announce acknowledgment
> + *
> + * The command VIRTIO_NET_CTRL_ANNOUNCE_ACK is used to indicate that driver has
> + * recevied the notification; device would clear the VIRTIO_NET_S_ANNOUNCE bit
> + * in the status field after it receives this command.
> + */
> +#define VIRTIO_NET_CTRL_ANNOUNCE 3
> +#define VIRTIO_NET_CTRL_ANNOUNCE_ACK 0
> +
> +/*
> + * Control receive flow steering
> + *
> + * The command VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET enables receive flow steering,
> + * specifying the number of the transmit and receive queues that will be used.
> + * After the command is consumed and acked by the device, the device will not
> + * steer new packets on receive virtqueues other than specified nor read from
> + * transmit virtqueues other than specified. Accordingly, driver should not
> + * transmit new packets on virtqueues other than specified.
> + */
> +struct virtio_net_ctrl_mq {
> + __virtio16 virtqueue_pairs;
> +};
> +
> +#define VIRTIO_NET_CTRL_MQ 4
> +#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET 0
> +#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN 1
> +#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX 0x8000
> +
> +/*
> + * Control network offloads
> + *
> + * Reconfigures the network offloads that guest can handle.
> + *
> + * Available with the VIRTIO_NET_F_CTRL_GUEST_OFFLOADS feature bit.
> + *
> + * Command data format matches the feature bit mask exactly.
> + *
> + * See VIRTIO_NET_F_GUEST_* for the list of offloads
> + * that can be enabled/disabled.
> + */
> +#define VIRTIO_NET_CTRL_GUEST_OFFLOADS 5
> +#define VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET 0
> +
> +#endif /* _LINUX_VIRTIO_NET_H */
> --
> 2.7.4
>
> _______________________________________________
> U-Boot mailing list
> U-Boot at lists.denx.de
> https://lists.denx.de/listinfo/u-boot
^ permalink raw reply [flat|nested] 82+ messages in thread
end of thread, other threads:[~2018-10-22 23:09 UTC | newest]
Thread overview: 82+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-09-23 13:41 [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Bin Meng
2018-09-23 13:41 ` [U-Boot] [PATCH 01/27] dm: core: Allow uclass to set up a device's child after it is probed Bin Meng
2018-09-27 13:41 ` Simon Glass
2018-10-11 5:14 ` Bin Meng
2018-09-23 13:42 ` [U-Boot] [PATCH 02/27] dm: Add a new uclass driver for VirtIO transport devices Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-10-11 9:08 ` Bin Meng
2018-09-27 22:10 ` Tuomas Tynkkynen
2018-10-11 9:09 ` Bin Meng
2018-09-23 13:42 ` [U-Boot] [PATCH 03/27] virtio: Add codes for virtual queue/ring management Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-10-11 9:50 ` Bin Meng
2018-10-12 0:00 ` Simon Glass
2018-09-27 22:11 ` Tuomas Tynkkynen
2018-10-02 15:46 ` Bin Meng
2018-09-23 13:42 ` [U-Boot] [PATCH 04/27] virtio: Add virtio over mmio transport driver Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 05/27] virtio: Add net driver support Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-27 22:12 ` Tuomas Tynkkynen
2018-10-02 16:10 ` Bin Meng
2018-10-22 23:09 ` Joe Hershberger
2018-09-23 13:42 ` [U-Boot] [PATCH 06/27] test: dm: blk: Correct blk_base test case Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 07/27] sandbox: blk: Switch to use platdata_auto_alloc_size for the driver data Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 08/27] efi_driver: " Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 09/27] blk: Call part_init() in the post_probe() method Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 10/27] blk: Drop blk_prepare_device() Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 11/27] blk: Make blk_next_free_devnum() public Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 12/27] blk: Introduce IF_TYPE_VIRTIO Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 13/27] virtio: Add block driver support Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-27 22:12 ` Tuomas Tynkkynen
2018-09-23 13:42 ` [U-Boot] [PATCH 14/27] virtio: cmd: Add virtio command for virtio block devices Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 15/27] arm: qemu: Add a Kconfig in the board directory Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 16/27] arm: qemu: Enumerate virtio bus during early boot Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-10-11 13:21 ` Bin Meng
2018-09-27 22:13 ` Tuomas Tynkkynen
2018-10-11 13:28 ` Bin Meng
2018-09-23 13:42 ` [U-Boot] [PATCH 17/27] riscv: " Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 18/27] riscv: qemu: Include some useful commands Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-27 22:14 ` Tuomas Tynkkynen
2018-10-02 16:03 ` Bin Meng
2018-09-23 13:42 ` [U-Boot] [PATCH 19/27] kconfig: Introduce HAVE_ARCH_IOMAP Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 20/27] x86: Implement arch-specific io accessor routines Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-10-11 13:33 ` Bin Meng
2018-09-23 13:42 ` [U-Boot] [PATCH 21/27] virtio: Add virtio over pci transport driver Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-10-11 13:39 ` Bin Meng
2018-09-23 13:42 ` [U-Boot] [PATCH 22/27] x86: qemu: Imply virtio PCI transport and device drivers Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 23/27] dm: pci: Add APIs to find next capability and extended capability Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 24/27] test: dm: pci: Add cases for finding next PCI capability APIs Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-09-23 13:42 ` [U-Boot] [PATCH 25/27] virtio: pci: Support non-legacy PCI transport device Bin Meng
2018-09-27 13:42 ` Simon Glass
2018-10-11 13:41 ` Bin Meng
2018-09-23 13:42 ` [U-Boot] [PATCH 26/27] virtio: net: Support non-legacy device Bin Meng
2018-09-27 13:43 ` Simon Glass
2018-10-15 21:59 ` Joe Hershberger
2018-09-23 13:42 ` [U-Boot] [PATCH 27/27] doc: Document virtio support Bin Meng
2018-09-27 13:43 ` Simon Glass
2018-09-27 13:43 ` [U-Boot] [PATCH 00/27] virtio: Introduce VirtIO driver support Simon Glass
2018-09-27 22:19 ` Tuomas Tynkkynen
2018-10-02 11:21 ` Simon Glass
2018-10-04 7:00 ` Bin Meng
2018-10-09 16:20 ` Simon Glass
2018-10-10 15:35 ` Bin Meng
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.