Skip to contentSkip to conversation

Add virtio-mmio support to m68k virt machine

PATCH In review Daniel Palmer 3 participants 12 messages May 16 – May 23

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

v7 cover Add virtio-mmio support to m68k virt machine

Lets start making the m68k virt machine support useful.

First we need to fix some m68k endian issues.

Then allow virtio mmio driver instances to be created with platform data and fix a minor endian issue.

Finally, add the code for the board to create the instances.

v7:
- An extra patch is added before changing the qemu sysreset driver to use __raw_writel() to fix issues with versions of writel()/__raw_writel() that don't cast the address to a pointer.
- Hopefully this fixes all of the CI issues. I have tested locally by building a few different targets with allyesconfig. A github pipeline passed with this patch and its running again now since I rebase and force pushed.

v6:
- Remove an extra signed-of-by that go added by b4 or me somehow.
- Fix the warning about a phys_addr_t being cast to a pointer of different size if phys_addr_t is 32bits but the target cpu is 64bits.

CC drivers/virtio/virtio_mmio.o
drivers/virtio/virtio_mmio.c: In function ‘virtio_mmio_probe’:
drivers/virtio/virtio_mmio.c:359:22: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]

  359 |         priv->base = (void __iomem *)plat->base;
      |

v5:
- Add Kuan-Wei's fixes for the two other goldfish endian issues I hadn't spotted. Should be good to go!

v4:
- Small changes to "board: qemu: m68k: Create virtio mmio instances" requested by Simon.
- Add another patch to make the virtio cmd depend on CONFIG_VIRTIO_BLK as the build breaks if it isn't selected.

v3:
- Fix the bug with the vendor string in virtio-blk properly, this removes the last endian hack in virtio-mmio
- Leave the current behaviour for readl() for coldfire as it breaks thing.

v2:
- Added patch to fix readl() etc on m68k, hopefully this doesn't break everything. This should match Linux now.
- Added patch to fix sys reset which is broken by the above
- Hacks to virtio-mmio are gone because they aren't needed anymore, just one minor endian fix now.
- Removed RFC because it looks good to me*.

* I wouldn't trust me. :)

Daniel Palmer (7):
sysreset: qemu virt: Use map_sysmem()
sysreset: qemu virt: Use __raw_writel()
m68k: Fix writew(), writel(), readw(), readl() endianness for classic

    m68k

virtio: mmio: Allow instantiation via platform data
virtio: cmd: Depend on VIRTIO_BLK
virtio: blk: Fix converting the vendor id to a string
board: qemu: m68k: Create virtio mmio instances

Kuan-Wei Chiu (2):
rtc: goldfish: Use __raw_readl() and __raw_writel()
timer: goldfish: Use __raw_readl()

 arch/m68k/Kconfig                          | 14 ++++---
 arch/m68k/include/asm/io.h                 | 31 +++++++++------
 board/emulation/qemu-m68k/qemu-m68k.c      | 45 ++++++++++++++++++++++
 cmd/Kconfig                                |  4 +-
 drivers/rtc/goldfish_rtc.c                 |  8 ++--
 drivers/sysreset/sysreset_qemu_virt_ctrl.c |  4 +-
 drivers/timer/goldfish_timer.c             |  4 +-
 drivers/virtio/virtio_blk.c                | 11 ++----
 drivers/virtio/virtio_mmio.c               | 27 ++++++++-----
 include/virtio.h                           |  3 ++
 include/virtio_mmio.h                      | 12 ++++++
 11 files changed, 121 insertions(+), 42 deletions(-)
 create mode 100644 include/virtio_mmio.h
Signature · 1 line
2.53.0
#1 lore raw

PATCH v7 1/9 sysreset: qemu virt: Use map_sysmem()

In the platform data there is a phys_addr_t (an integer) for the address of the register and we pass that as-is into writel() which is fine in most places because we don't need to do any mapping and the macro for writel() does a cast to a pointer.

If writel() is a static inline function the address argument is a pointer so passing it in as an integer without casting it first causes warnings or build failure.

map_sysmem() handles the casting part and if phys_addr_t is 32bits when on a 64bit machine.

---
 drivers/sysreset/sysreset_qemu_virt_ctrl.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/sysreset/sysreset_qemu_virt_ctrl.c +3 -1
index e7cacc9b6e98..61b38d507fc5 100644
@@ -8,6 +8,7 @@
 #include <dm.h>
 #include <qemu_virt_ctrl.h>
 #include <sysreset.h>
+#include <mapmem.h>
 #include <asm/io.h>
 #include <linux/err.h>
 
@@ -24,6 +25,7 @@
 static int qemu_virt_ctrl_request(struct udevice *dev, enum sysreset_t type)
 {
 	struct qemu_virt_ctrl_plat *plat = dev_get_plat(dev);
+	void __iomem *reg = map_sysmem(plat->reg + VIRT_CTRL_REG_CMD, 0x4);
 	u32 val;
 
 	switch (type) {
@@ -38,7 +40,7 @@ static int qemu_virt_ctrl_request(struct udevice *dev, enum sysreset_t type)
 		return -EPROTONOSUPPORT;
 	}
 
-	writel(val, plat->reg + VIRT_CTRL_REG_CMD);
+	writel(val, reg);
 
 	return -EINPROGRESS;
 }
Signature · 1 line
2.53.0
Acked-by on v7 1/9
#2 lore raw

Re: [PATCH v7 1/9] sysreset: qemu virt: Use map_sysmem()

Quoted 5 lines · Daniel Palmer

In the platform data there is a phys_addr_t (an integer) for the address of the register and we pass that as-is into writel() which is fine in most places because we don't need to do any mapping and the macro for writel() does a cast to a pointer.

Quoted 8 lines

If writel() is a static inline function the address argument is a pointer so passing it in as an integer without casting it first causes warnings or build failure.

map_sysmem() handles the casting part and if phys_addr_t is 32bits when on a 64bit machine.

Quoted 36 lines
---
 drivers/sysreset/sysreset_qemu_virt_ctrl.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/sysreset/sysreset_qemu_virt_ctrl.c +3 -1
index e7cacc9b6e98..61b38d507fc5 100644
@@ -8,6 +8,7 @@
 #include <dm.h>
 #include <qemu_virt_ctrl.h>
 #include <sysreset.h>
+#include <mapmem.h>
 #include <asm/io.h>
 #include <linux/err.h>
 
@@ -24,6 +25,7 @@
 static int qemu_virt_ctrl_request(struct udevice *dev, enum sysreset_t type)
 {
 	struct qemu_virt_ctrl_plat *plat = dev_get_plat(dev);
+	void __iomem *reg = map_sysmem(plat->reg + VIRT_CTRL_REG_CMD, 0x4);
 	u32 val;
 
 	switch (type) {
@@ -38,7 +40,7 @@ static int qemu_virt_ctrl_request(struct udevice *dev, enum sysreset_t type)
 		return -EPROTONOSUPPORT;
 	}
 
-	writel(val, plat->reg + VIRT_CTRL_REG_CMD);
+	writel(val, reg);
 
 	return -EINPROGRESS;
 }
Signature · 1 line
2.53.0
#3 lore raw

PATCH v7 2/9 sysreset: qemu virt: Use __raw_writel()

In reply to Daniel Palmer

The virt ctrl register seems to be native endian, currently this driver uses writel(), which works by luck because its currently broken on m68k.

Use __raw_writel() instead to avoid breaking this driver when the endianness of writel() is fixed.

---
 drivers/sysreset/sysreset_qemu_virt_ctrl.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/sysreset/sysreset_qemu_virt_ctrl.c +1 -1
index 61b38d507fc5..ce15e776f8fa 100644
@@ -40,7 +40,7 @@ static int qemu_virt_ctrl_request(struct udevice *dev, enum sysreset_t type)
 		return -EPROTONOSUPPORT;
 	}
 
-	writel(val, reg);
+	__raw_writel(val, reg);
 
 	return -EINPROGRESS;
 }
Signature · 1 line
2.53.0
#4 lore raw

PATCH v7 3/9 rtc: goldfish: Use __raw_readl() and __raw_writel()

In reply to Daniel Palmer

From: Kuan-Wei Chiu <[email protected]>

In QEMU, the Goldfish RTC is explicitly instantiated as a big-endian device on the m68k virt machine (via the 'big-endian=true' property). Currently, this driver uses ioread32() and iowrite32(), which works by luck because the underlying readl() and writel() are currently broken on m68k.

Use __raw_readl() and __raw_writel() instead to avoid breaking this driver when the endianness of readl() and writel() is fixed.

---
 drivers/rtc/goldfish_rtc.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/rtc/goldfish_rtc.c +4 -4
index d2991ca67192..4892a63f8d80 100644
@@ -40,8 +40,8 @@ static int goldfish_rtc_get(struct udevice *dev, struct rtc_time *time)
 	u64 time_low;
 	u64 now;
 
-	time_low = ioread32(base + GOLDFISH_TIME_LOW);
-	time_high = ioread32(base + GOLDFISH_TIME_HIGH);
+	time_low = __raw_readl(base + GOLDFISH_TIME_LOW);
+	time_high = __raw_readl(base + GOLDFISH_TIME_HIGH);
 	now = (time_high << 32) | time_low;
 
 	do_div(now, 1000000000U);
@@ -62,8 +62,8 @@ static int goldfish_rtc_set(struct udevice *dev, const struct rtc_time *time)
 		return -EINVAL;
 
 	now = rtc_mktime(time) * 1000000000ULL;
-	iowrite32(now >> 32, base + GOLDFISH_TIME_HIGH);
-	iowrite32(now, base + GOLDFISH_TIME_LOW);
+	__raw_writel(now >> 32, base + GOLDFISH_TIME_HIGH);
+	__raw_writel(now, base + GOLDFISH_TIME_LOW);
 
 	if (time->tm_isdst > 0)
 		priv->isdst = 1;
Signature · 1 line
2.53.0
#5 lore raw

PATCH v7 4/9 timer: goldfish: Use __raw_readl()

In reply to Daniel Palmer

From: Kuan-Wei Chiu <[email protected]>

The Goldfish timer registers are native endian, so they act as big-endian on the m68k virt machine. Currently, this driver uses readl(), which works by luck because it's currently broken on m68k.

Use __raw_readl() instead to avoid breaking this driver when the endianness of readl() is fixed.

---
 drivers/timer/goldfish_timer.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/timer/goldfish_timer.c +2 -2
index 70673bbd93c2..91277d7932ac 100644
@@ -31,8 +31,8 @@ static u64 goldfish_timer_get_count(struct udevice *dev)
 	 * We must read LOW before HIGH to latch the high 32-bit value
 	 * and ensure a consistent 64-bit timestamp.
 	 */
-	low = readl(priv->base + TIMER_TIME_LOW);
-	high = readl(priv->base + TIMER_TIME_HIGH);
+	low = __raw_readl(priv->base + TIMER_TIME_LOW);
+	high = __raw_readl(priv->base + TIMER_TIME_HIGH);
 
 	time = ((u64)high << 32) | low;
 
Signature · 1 line
2.53.0
#6 lore raw

PATCH v7 5/9 m68k: Fix writew(), writel(), readw(), readl() endianness for classic m68k

In reply to Daniel Palmer

In Linux these are meant to read a little-endian value and swap to the CPU endian.

In u-boot for m68k this is currently broken and prevents virtio-mmio from functioning.

This change is only for classic m68k. Coldfire has read big-endian, no swap for these in u-boot and Linux and existing drivers probably depend on this.

---
 arch/m68k/include/asm/io.h | 31 ++++++++++++++++++++-----------
 1 file changed, 20 insertions(+), 11 deletions(-)
arch/m68k/include/asm/io.h +20 -11
index 35ad4a1c0444..2577081d8363 100644
@@ -23,18 +23,27 @@
 #define __raw_writew(w,addr) ((*(volatile u16 *) (addr)) = (w))
 #define __raw_writel(l,addr) ((*(volatile u32 *) (addr)) = (l))
 
-#define readb(addr)		in_8((volatile u8 *)(addr))
-#define writeb(b,addr)		out_8((volatile u8 *)(addr), (b))
-#if !defined(__BIG_ENDIAN)
-#define readw(addr)		(*(volatile u16 *) (addr))
-#define readl(addr)		(*(volatile u32 *) (addr))
-#define writew(b,addr)		((*(volatile u16 *) (addr)) = (b))
-#define writel(b,addr)		((*(volatile u32 *) (addr)) = (b))
+#define readb(addr)	in_8((volatile u8 *)(addr))
+#define writeb(b, addr)	out_8((volatile u8 *)(addr), (b))
+#ifdef CONFIG_M680x0
+/*
+ * For classic m68k these work the same way as Linux:
+ * Read a little endian value, swap to the CPU endian.
+ */
+#define readw(addr)	in_le16((volatile u16 *)(addr))
+#define readl(addr)	in_le32((volatile u32 *)(addr))
+#define writew(b, addr)	out_le16((volatile u16 *)(addr), (b))
+#define writel(b, addr)	out_le32((volatile u32 *)(addr), (b))
 #else
-#define readw(addr)		in_be16((volatile u16 *)(addr))
-#define readl(addr)		in_be32((volatile u32 *)(addr))
-#define writew(b,addr)		out_be16((volatile u16 *)(addr),(b))
-#define writel(b,addr)		out_be32((volatile u32 *)(addr),(b))
+/*
+ * For coldfire these read a big endian value and use it
+ * as-is. This means that for little endian devices on the
+ * bus like PCI device these won't work as expected currently.
+ */
+#define readw(addr)	in_be16((volatile u16 *)(addr))
+#define readl(addr)	in_be32((volatile u32 *)(addr))
+#define writew(b, addr)	out_be16((volatile u16 *)(addr), (b))
+#define writel(b, addr)	out_be32((volatile u32 *)(addr), (b))
 #endif
 
 /*
Signature · 1 line
2.53.0
#7 lore raw

PATCH v7 6/9 virtio: mmio: Allow instantiation via platform data

In reply to Daniel Palmer

The m68k QEMU virt machine doesn't use devicetree, yet, so allow it to create virtio-mmio instances via platform data.

---
 drivers/virtio/virtio_mmio.c | 27 ++++++++++++++++++---------
 include/virtio_mmio.h        | 12 ++++++++++++
 2 files changed, 30 insertions(+), 9 deletions(-)
 create mode 100644 include/virtio_mmio.h
drivers/virtio/virtio_mmio.c +18 -9
index d90d8309f991..975f98cd9e5b 100644
@@ -12,6 +12,7 @@
 #include <virtio_types.h>
 #include <virtio.h>
 #include <virtio_ring.h>
+#include <virtio_mmio.h>
 #include <linux/bug.h>
 #include <linux/compat.h>
 #include <linux/err.h>
@@ -335,21 +336,28 @@ static int virtio_mmio_notify(struct udevice *udev, struct virtqueue *vq)
 
 static int virtio_mmio_of_to_plat(struct udevice *udev)
 {
-	struct virtio_mmio_priv *priv = dev_get_priv(udev);
+	struct virtio_mmio_plat *plat = dev_get_plat(udev);
+	fdt_addr_t addr;
+
+	addr = dev_read_addr(udev);
 
-	priv->base = (void __iomem *)(ulong)dev_read_addr(udev);
-	if (priv->base == (void __iomem *)FDT_ADDR_T_NONE)
+	if (addr == FDT_ADDR_T_NONE)
 		return -EINVAL;
 
+	plat->base = addr;
+
 	return 0;
 }
 
 static int virtio_mmio_probe(struct udevice *udev)
 {
+	struct virtio_mmio_plat *plat = dev_get_plat(udev);
 	struct virtio_mmio_priv *priv = dev_get_priv(udev);
 	struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
 	u32 magic;
 
+	priv->base = (void __iomem *)(uintptr_t)plat->base;
+
 	/* Check magic value */
 	magic = readl(priv->base + VIRTIO_MMIO_MAGIC_VALUE);
 	if (magic != ('v' | 'i' << 8 | 'r' << 16 | 't' << 24)) {
@@ -405,11 +413,12 @@ static const struct udevice_id virtio_mmio_ids[] = {
 };
 
 U_BOOT_DRIVER(virtio_mmio) = {
-	.name	= "virtio-mmio",
-	.id	= UCLASS_VIRTIO,
-	.of_match = virtio_mmio_ids,
-	.ops	= &virtio_mmio_ops,
-	.probe	= virtio_mmio_probe,
+	.name       = "virtio-mmio",
+	.id         = UCLASS_VIRTIO,
+	.of_match   = virtio_mmio_ids,
+	.ops        = &virtio_mmio_ops,
+	.probe      = virtio_mmio_probe,
 	.of_to_plat = virtio_mmio_of_to_plat,
-	.priv_auto	= sizeof(struct virtio_mmio_priv),
+	.priv_auto  = sizeof(struct virtio_mmio_priv),
+	.plat_auto  = sizeof(struct virtio_mmio_plat),
 };
include/virtio_mmio.h new file +12 -0
new file mode 100644
index 000000000000..8c072826db55
@@ -0,0 +1,12 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+
+#ifndef __VIRTIO_MMIO_H__
+#define __VIRTIO_MMIO_H__
+
+#include <linux/types.h>
+
+struct virtio_mmio_plat {
+	phys_addr_t base;
+};
+
+#endif /* __VIRTIO_MMIO_H__ */
Signature · 1 line
2.53.0
#8 lore raw

PATCH v7 7/9 virtio: cmd: Depend on VIRTIO_BLK

In reply to Daniel Palmer

The virtio command is calling virtio blk functions but currently depends on CONFIG_VIRTIO only. This means disabling CONFIG_VIRTIO_BLK causes the final link to fail.

Since CONFIG_VIRTIO_BLK depends on CONFIG_VIRTIO switch to depending on just CONFIG_VIRTIO_BLK

---
 cmd/Kconfig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
cmd/Kconfig +2 -2
index c71c6824a196..032e55e81276 100644
@@ -1871,8 +1871,8 @@ config CMD_PVBLOCK
 
 config CMD_VIRTIO
 	bool "virtio"
-	depends on VIRTIO
-	default y if VIRTIO
+	depends on VIRTIO_BLK
+	default y if VIRTIO_BLK
 	help
 	  VirtIO block device support
 
Signature · 1 line
2.53.0
#9 lore raw

PATCH v7 8/9 virtio: blk: Fix converting the vendor id to a string

In reply to Daniel Palmer

Currently we are trying to work out if the vendor id is from a virtio-mmio device and then casting a u32 to a char* and using it as a C-string. By chance there is usually a zero after the u32 and it works.

Since the vendor id we are trying to convert to a string is QEMU's just define a value for the QEMU vendor id, check if the vendor id matches and then use a predefined string for "QEMU".

I don't think we should have been assumming all virtio-mmio vendor ids are printable ASCII chars in the first place so do this special casing just for QEMU. If the vendor id isn't QEMU print the hex value of it.

---
 drivers/virtio/virtio_blk.c | 11 ++++-------
 include/virtio.h            |  3 +++
 2 files changed, 7 insertions(+), 7 deletions(-)
drivers/virtio/virtio_blk.c +4 -7
index 7b1d891cdcbb..404d9140cb2b 100644
@@ -232,14 +232,11 @@ static int virtio_blk_bind(struct udevice *dev)
 		return devnum;
 	desc->devnum = devnum;
 	desc->part_type = PART_TYPE_UNKNOWN;
-	/*
-	 * virtio mmio transport supplies string identification for us,
-	 * while pci trnasport uses a 2-byte subvendor value.
-	 */
-	if (uc_priv->vendor >> 16)
-		sprintf(desc->vendor, "%s", (char *)&uc_priv->vendor);
+
+	if (uc_priv->vendor == VIRTIO_VENDOR_QEMU)
+		strcpy(desc->vendor, "QEMU");
 	else
-		sprintf(desc->vendor, "%04x", uc_priv->vendor);
+		sprintf(desc->vendor, "%08x", uc_priv->vendor);
 	desc->bdev = dev;
 
 	/* Indicate what driver features we support */
include/virtio.h +3 -0
index 17f894a79e31..3edf023463d7 100644
@@ -25,6 +25,9 @@
 #include <linux/bitops.h>
 #include <linux/bug.h>
 #include <linux/typecheck.h>
+
+#define VIRTIO_VENDOR_QEMU	0x554d4551
+
 #define VIRTIO_ID_NET		1 /* virtio net */
 #define VIRTIO_ID_BLOCK		2 /* virtio block */
 #define VIRTIO_ID_RNG		4 /* virtio rng */
Signature · 1 line
2.53.0
#10 lore raw

PATCH v7 9/9 board: qemu: m68k: Create virtio mmio instances

In reply to Daniel Palmer

So that you can use virtio network, block etc create the virtio mmio instances. There are 128 of these even if they are not all used, a single mmio base value is passed via bootinfo.

---
 arch/m68k/Kconfig                     | 14 +++++----
 board/emulation/qemu-m68k/qemu-m68k.c | 45 +++++++++++++++++++++++++++
 2 files changed, 53 insertions(+), 6 deletions(-)
arch/m68k/Kconfig +8 -6
index 00e89bd0a625..8bebf0ea3e13 100644
@@ -196,12 +196,14 @@ config TARGET_STMARK2
         select M54418
 
 config TARGET_QEMU_M68K
-    bool "Support QEMU m68k virt"
-    select M68040
-    imply CMD_DM
-    help
-      This target supports the QEMU m68k virtual machine (-M virt).
-      It simulates a Motorola 68040 CPU with Goldfish peripherals.
+	bool "Support QEMU m68k virt"
+	select M68040
+	select BOARD_EARLY_INIT_R
+	select VIRTIO_MMIO
+	imply CMD_DM
+	help
+	  This target supports the QEMU m68k virtual machine (-M virt).
+	  It simulates a Motorola 68040 CPU with Goldfish peripherals.
 
 endchoice
 
board/emulation/qemu-m68k/qemu-m68k.c +45 -0

72 lines not on this page · raw message

Signature · 1 line
2.53.0
#11 lore raw
In reply to Daniel Palmer
Quoted 8 lines · Daniel Palmer

Lets start making the m68k virt machine support useful.

First we need to fix some m68k endian issues.

Then allow virtio mmio driver instances to be created with platform data and fix a minor endian issue.

[...]

Applied to u-boot/next, thanks!

[1/9] sysreset: qemu virt: Use map_sysmem()

      commit: ccec4ce2ee8ae7c95a00b16da0b5dbd88615a8e2
[2/9] sysreset: qemu virt: Use __raw_writel()
      commit: 0bcd158db30aa14aa6add56060626388079c50cf
[3/9] rtc: goldfish: Use __raw_readl() and __raw_writel()
      commit: 5116fed77dee99a513f17f18be0dbf2e63363eef
[4/9] timer: goldfish: Use __raw_readl()
      commit: 75a1d7280a72d587d54b6af653234a96210f7177
[5/9] m68k: Fix writew(), writel(), readw(), readl() endianness for classic m68k
      commit: 3e2b261647a78929f494a932fad4e80e607a2fef
[6/9] virtio: mmio: Allow instantiation via platform data
      commit: 009cd5b56dbc2d0f7675e4262347a1a6b6a55cb2
[7/9] virtio: cmd: Depend on VIRTIO_BLK
      commit: b781017fb63831abac4bb6956e83595f5cb8c428
[8/9] virtio: blk: Fix converting the vendor id to a string
      commit: ddba15ab72df5a01fd483a0f4fc40f9ae4d2475c
[9/9] board: qemu: m68k: Create virtio mmio instances
      commit: 3dc2761d6347c35fe15fef64592d20946396872d
Signature · 1 line
Tom