On 2/20/21 6:33 AM, Asherah Connor wrote:
Updates the QFW driver to use the driver model, and adds support for QFW
on Arm platforms by configuring from the device tree and using MMIO
accordingly.
Signed-off-by: Asherah Connor <[email protected]>
---
(no changes since v1)
arch/arm/Kconfig | 1 +
arch/x86/cpu/qemu/cpu.c | 7 +-
arch/x86/cpu/qemu/qemu.c | 54 ++------
arch/x86/cpu/qfw_cpu.c | 11 +-
cmd/qfw.c | 44 +++---
drivers/misc/Kconfig | 1 +
drivers/misc/qfw.c | 287 +++++++++++++++++++++++++++------------
include/qfw.h | 63 +++++----
8 files changed, 291 insertions(+), 177 deletions(-)
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index d51abbeaf0..3841ae3ba2 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -937,6 +937,7 @@ config ARCH_QEMU
imply DM_RNG
imply DM_RTC
imply RTC_PL031
+ imply QFW
With qemu_arm64_defonfig this imply has no effect because QFW depends on
MISC which is not selected.
Building qemu-x86_64_defconfig with your patch generates warnings:
WARNING: unmet direct dependencies detected for QFW
Depends on [n]: MISC [=n]
Selected by [y]:
- GENERATE_ACPI_TABLE [=y] && X86 [=y] && !EFI [=n] && !SYS_COREBOOT
[=n] && QEMU [=y]
- CMD_QFW [=y]
I suggest that you use 'imply cmd_qfw' as this allows deselection by the
user and make the following change in a separate patch:
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 0a65f29acd..f342378e04 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -367,5 +367,5 @@ config WINBOND_W83627
config QFW
bool
- depends on MISC
+ select MISC
config ARCH_RMOBILE
bool "Renesas ARM SoCs"
diff --git a/arch/x86/cpu/qemu/cpu.c b/arch/x86/cpu/qemu/cpu.c
index 9ce86b379c..ab1b797f9a 100644
--- a/arch/x86/cpu/qemu/cpu.c
+++ b/arch/x86/cpu/qemu/cpu.c
@@ -22,7 +22,12 @@ int cpu_qemu_get_desc(const struct udevice *dev, char *buf,
int size)
static int cpu_qemu_get_count(const struct udevice *dev)
{
- return qemu_fwcfg_online_cpus();
+ struct udevice *qfw_dev = qemu_fwcfg_dev();
+
+ if (!qfw_dev)
+ return -ENODEV;
+
+ return qemu_fwcfg_online_cpus(qfw_dev);
}
static const struct cpu_ops cpu_qemu_ops = {
diff --git a/arch/x86/cpu/qemu/qemu.c b/arch/x86/cpu/qemu/qemu.c
index 044a429c13..e255af9a4a 100644
--- a/arch/x86/cpu/qemu/qemu.c
+++ b/arch/x86/cpu/qemu/qemu.c
@@ -8,6 +8,7 @@
#include <init.h>
#include <pci.h>
#include <qfw.h>
+#include <dm/platdata.h>
#include <asm/irq.h>
#include <asm/post.h>
#include <asm/processor.h>
@@ -19,45 +20,20 @@ static bool i440fx;
#ifdef CONFIG_QFW
/* on x86, the qfw registers are all IO ports */
-#define FW_CONTROL_PORT 0x510
-#define FW_DATA_PORT 0x511
-#define FW_DMA_PORT_LOW 0x514
-#define FW_DMA_PORT_HIGH 0x518
-
-static void qemu_x86_fwcfg_read_entry_pio(uint16_t entry,
- uint32_t size, void *address)
-{
- uint32_t i = 0;
- uint8_t *data = address;
-
- /*
- * writting FW_CFG_INVALID will cause read operation to resume at
- * last offset, otherwise read will start at offset 0
- *
- * Note: on platform where the control register is IO port, the
- * endianness is little endian.
- */
- if (entry != FW_CFG_INVALID)
- outw(cpu_to_le16(entry), FW_CONTROL_PORT);
-
- /* the endianness of data register is string-preserving */
- while (size--)
- data[i++] = inb(FW_DATA_PORT);
-}
-
-static void qemu_x86_fwcfg_read_entry_dma(struct fw_cfg_dma_access *dma)
-{
- /* the DMA address register is big endian */
- outl(cpu_to_be32((uintptr_t)dma), FW_DMA_PORT_HIGH);
-
- while (be32_to_cpu(dma->control) & ~FW_CFG_DMA_ERROR)
- __asm__ __volatile__ ("pause");
-}
+static const struct qfw_plat x86_qfw_plat = {
+ .io = {
+ .control_port = 0x510,
+ .data_port = 0x511,
+ .dma_port_low = 0x514,
+ .dma_port_high = 0x518,
+ },
+};
-static struct fw_cfg_arch_ops fwcfg_x86_ops = {
- .arch_read_pio = qemu_x86_fwcfg_read_entry_pio,
- .arch_read_dma = qemu_x86_fwcfg_read_entry_dma
+U_BOOT_DRVINFO(x86_qfw) = {
+ .name = "qfw",
+ .plat = &x86_qfw_plat,
};
+
#endif
static void enable_pm_piix(void)
@@ -132,10 +108,6 @@ static void qemu_chipset_init(void)
enable_pm_ich9();
}
-
-#ifdef CONFIG_QFW
- qemu_fwcfg_init(&fwcfg_x86_ops);
-#endif
}
#if !CONFIG_IS_ENABLED(SPL_X86_32BIT_INIT)
diff --git a/arch/x86/cpu/qfw_cpu.c b/arch/x86/cpu/qfw_cpu.c
index b959eaddde..c8fb918494 100644
--- a/arch/x86/cpu/qfw_cpu.c
+++ b/arch/x86/cpu/qfw_cpu.c
@@ -18,7 +18,7 @@ int qemu_cpu_fixup(void)
int cpu_num;
int cpu_online;
struct uclass *uc;
- struct udevice *dev, *pdev;
+ struct udevice *dev, *pdev, *qfwdev;
struct cpu_plat *plat;
char *cpu;
@@ -39,6 +39,13 @@ int qemu_cpu_fixup(void)
return -ENODEV;
}
+ /* get qfw dev */
+ qfwdev = qemu_fwcfg_dev();
+ if (!qfwdev) {
+ printf("unable to find qfw device\n");
+ return -ENODEV;
+ }
+
/* calculate cpus that are already bound */
cpu_num = 0;
for (uclass_find_first_device(UCLASS_CPU, &dev);
@@ -48,7 +55,7 @@ int qemu_cpu_fixup(void)
}
/* get actual cpu number */
- cpu_online = qemu_fwcfg_online_cpus();
+ cpu_online = qemu_fwcfg_online_cpus(qfwdev);
if (cpu_online < 0) {
printf("unable to get online cpu number: %d\n", cpu_online);
return cpu_online;
diff --git a/cmd/qfw.c b/cmd/qfw.c
index bb571487f0..ec80a9a3b5 100644
--- a/cmd/qfw.c
+++ b/cmd/qfw.c
@@ -8,19 +8,22 @@
#include <env.h>
#include <errno.h>
#include <qfw.h>
+#include <dm.h>
+
+static struct udevice *qfw_dev;
/*
* This function prepares kernel for zboot. It loads kernel data
* to 'load_addr', initrd to 'initrd_addr' and kernel command
* line using qemu fw_cfg interface.
*/
-static int qemu_fwcfg_setup_kernel(void *load_addr, void *initrd_addr)
+static int qemu_fwcfg_cmd_setup_kernel(void *load_addr, void *initrd_addr)
{
char *data_addr;
uint32_t setup_size, kernel_size, cmdline_size, initrd_size;
- qemu_fwcfg_read_entry(FW_CFG_SETUP_SIZE, 4, &setup_size);
- qemu_fwcfg_read_entry(FW_CFG_KERNEL_SIZE, 4, &kernel_size);
+ qemu_fwcfg_read_entry(qfw_dev, FW_CFG_SETUP_SIZE, 4, &setup_size);
+ qemu_fwcfg_read_entry(qfw_dev, FW_CFG_KERNEL_SIZE, 4, &kernel_size);
if (setup_size == 0 || kernel_size == 0) {
printf("warning: no kernel available\n");
@@ -28,27 +31,27 @@ static int qemu_fwcfg_setup_kernel(void *load_addr, void
*initrd_addr)
}
data_addr = load_addr;
- qemu_fwcfg_read_entry(FW_CFG_SETUP_DATA,
+ qemu_fwcfg_read_entry(qfw_dev, FW_CFG_SETUP_DATA,
le32_to_cpu(setup_size), data_addr);
data_addr += le32_to_cpu(setup_size);
- qemu_fwcfg_read_entry(FW_CFG_KERNEL_DATA,
+ qemu_fwcfg_read_entry(qfw_dev, FW_CFG_KERNEL_DATA,
le32_to_cpu(kernel_size), data_addr);
data_addr += le32_to_cpu(kernel_size);
data_addr = initrd_addr;
- qemu_fwcfg_read_entry(FW_CFG_INITRD_SIZE, 4, &initrd_size);
+ qemu_fwcfg_read_entry(qfw_dev, FW_CFG_INITRD_SIZE, 4, &initrd_size);
if (initrd_size == 0) {
printf("warning: no initrd available\n");
} else {
- qemu_fwcfg_read_entry(FW_CFG_INITRD_DATA,
+ qemu_fwcfg_read_entry(qfw_dev, FW_CFG_INITRD_DATA,
le32_to_cpu(initrd_size), data_addr);
data_addr += le32_to_cpu(initrd_size);
}
- qemu_fwcfg_read_entry(FW_CFG_CMDLINE_SIZE, 4, &cmdline_size);
+ qemu_fwcfg_read_entry(qfw_dev, FW_CFG_CMDLINE_SIZE, 4, &cmdline_size);
if (cmdline_size) {
- qemu_fwcfg_read_entry(FW_CFG_CMDLINE_DATA,
+ qemu_fwcfg_read_entry(qfw_dev, FW_CFG_CMDLINE_DATA,
le32_to_cpu(cmdline_size), data_addr);
/*
* if kernel cmdline only contains '\0', (e.g. no -append
@@ -72,19 +75,18 @@ static int qemu_fwcfg_setup_kernel(void *load_addr, void
*initrd_addr)
return 0;
}
-static int qemu_fwcfg_list_firmware(void)
+static int qemu_fwcfg_cmd_list_firmware(void)
{
int ret;
struct fw_cfg_file_iter iter;
struct fw_file *file;
/* make sure fw_list is loaded */
- ret = qemu_fwcfg_read_firmware_list();
+ ret = qemu_fwcfg_read_firmware_list(qfw_dev);
if (ret)
return ret;
-
- for (file = qemu_fwcfg_file_iter_init(&iter);
+ for (file = qemu_fwcfg_file_iter_init(qfw_dev, &iter);
!qemu_fwcfg_file_iter_end(&iter);
file = qemu_fwcfg_file_iter_next(&iter)) {
printf("%-56s\n", file->cfg.name);
@@ -96,7 +98,7 @@ static int qemu_fwcfg_list_firmware(void)
static int qemu_fwcfg_do_list(struct cmd_tbl *cmdtp, int flag,
int argc, char *const argv[])
{
- if (qemu_fwcfg_list_firmware() < 0)
+ if (qemu_fwcfg_cmd_list_firmware() < 0)
return CMD_RET_FAILURE;
return 0;
@@ -105,14 +107,7 @@ static int qemu_fwcfg_do_list(struct cmd_tbl *cmdtp, int
flag,
static int qemu_fwcfg_do_cpus(struct cmd_tbl *cmdtp, int flag,
int argc, char *const argv[])
{
- int ret = qemu_fwcfg_online_cpus();
- if (ret < 0) {
- printf("QEMU fw_cfg interface not found\n");
- return CMD_RET_FAILURE;
- }
-
- printf("%d cpu(s) online\n", qemu_fwcfg_online_cpus());
-
+ printf("%d cpu(s) online\n", qemu_fwcfg_online_cpus(qfw_dev));
return 0;
}
@@ -153,7 +148,7 @@ static int qemu_fwcfg_do_load(struct cmd_tbl *cmdtp, int
flag,
return CMD_RET_FAILURE;
}
- return qemu_fwcfg_setup_kernel(load_addr, initrd_addr);
+ return qemu_fwcfg_cmd_setup_kernel(load_addr, initrd_addr);
}
static struct cmd_tbl fwcfg_commands[] = {
@@ -168,7 +163,8 @@ static int do_qemu_fw(struct cmd_tbl *cmdtp, int flag, int
argc,
int ret;
struct cmd_tbl *fwcfg_cmd;
- if (!qemu_fwcfg_present()) {
+ qfw_dev = qemu_fwcfg_dev();
+ if (!qfw_dev) {
printf("QEMU fw_cfg interface not found\n");
return CMD_RET_USAGE;
}
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 7d2a299779..0a65f29acd 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -367,6 +367,7 @@ config WINBOND_W83627
config QFW
bool
+ depends on MISC
help
Hidden option to enable QEMU fw_cfg interface. This will be selected
by
either CONFIG_CMD_QFW or CONFIG_GENERATE_ACPI_TABLE.
diff --git a/drivers/misc/qfw.c b/drivers/misc/qfw.c
index f6eb6583ed..58dc47a0b5 100644
--- a/drivers/misc/qfw.c
+++ b/drivers/misc/qfw.c
@@ -9,17 +9,18 @@
#include <log.h>
#include <malloc.h>
#include <qfw.h>
+#include <dm.h>
#include <asm/io.h>
+#include <misc.h>
#ifdef CONFIG_GENERATE_ACPI_TABLE
#include <asm/tables.h>
#endif
-#include <linux/list.h>
-static bool fwcfg_present;
-static bool fwcfg_dma_present;
-static struct fw_cfg_arch_ops *fwcfg_arch_ops;
-
-static LIST_HEAD(fw_list);
+/* Determined at runtime. */
+struct qfw_priv {
+ bool dma_present;
+ struct list_head fw_list;
+};
#ifdef CONFIG_GENERATE_ACPI_TABLE
/*
@@ -32,7 +33,8 @@ static LIST_HEAD(fw_list);
* be ignored.
* @return: 0 on success, or negative value on failure
*/
-static int bios_linker_allocate(struct bios_linker_entry *entry, ulong *addr)
+static int bios_linker_allocate(struct udevice *dev,
+ struct bios_linker_entry *entry, ulong *addr)
{
uint32_t size, align;
struct fw_file *file;
@@ -45,7 +47,7 @@ static int bios_linker_allocate(struct bios_linker_entry
*entry, ulong *addr)
return -EINVAL;
}
- file = qemu_fwcfg_find_file(entry->alloc.file);
+ file = qemu_fwcfg_find_file(dev, entry->alloc.file);
if (!file) {
printf("error: can't find file %s\n", entry->alloc.file);
return -ENOENT;
@@ -75,7 +77,7 @@ static int bios_linker_allocate(struct bios_linker_entry
*entry, ulong *addr)
debug("bios_linker_allocate: allocate file %s, size %u, zone %d, align %u,
addr 0x%lx\n",
file->cfg.name, size, entry->alloc.zone, align, aligned_addr);
- qemu_fwcfg_read_entry(be16_to_cpu(file->cfg.select),
+ qemu_fwcfg_read_entry(dev, be16_to_cpu(file->cfg.select),
size, (void *)aligned_addr);
file->addr = aligned_addr;
@@ -94,16 +96,17 @@ static int bios_linker_allocate(struct bios_linker_entry
*entry, ulong *addr)
* ACPI tables
* @return: 0 on success, or negative value on failure
*/
-static int bios_linker_add_pointer(struct bios_linker_entry *entry)
+static int bios_linker_add_pointer(struct udevice *dev,
+ struct bios_linker_entry *entry)
{
struct fw_file *dest, *src;
uint32_t offset = le32_to_cpu(entry->pointer.offset);
uint64_t pointer = 0;
- dest = qemu_fwcfg_find_file(entry->pointer.dest_file);
+ dest = qemu_fwcfg_find_file(dev, entry->pointer.dest_file);
if (!dest || !dest->addr)
return -ENOENT;
- src = qemu_fwcfg_find_file(entry->pointer.src_file);
+ src = qemu_fwcfg_find_file(dev, entry->pointer.src_file);
if (!src || !src->addr)
return -ENOENT;
@@ -127,13 +130,14 @@ static int bios_linker_add_pointer(struct
bios_linker_entry *entry)
* checksums
* @return: 0 on success, or negative value on failure
*/
-static int bios_linker_add_checksum(struct bios_linker_entry *entry)
+static int bios_linker_add_checksum(struct udevice *dev,
+ struct bios_linker_entry *entry)
{
struct fw_file *file;
uint8_t *data, cksum = 0;
uint8_t *cksum_start;
- file = qemu_fwcfg_find_file(entry->cksum.file);
+ file = qemu_fwcfg_find_file(dev, entry->cksum.file);
if (!file || !file->addr)
return -ENOENT;
@@ -154,15 +158,22 @@ ulong write_acpi_tables(ulong addr)
struct bios_linker_entry *table_loader;
struct bios_linker_entry *entry;
uint32_t size;
+ struct udevice *dev;
+
+ dev = qemu_fwcfg_dev();
+ if (!dev) {
+ printf("error: no qfw\n");
+ return addr;
+ }
/* make sure fw_list is loaded */
- ret = qemu_fwcfg_read_firmware_list();
+ ret = qemu_fwcfg_read_firmware_list(dev);
if (ret) {
printf("error: can't read firmware file list\n");
return addr;
}
- file = qemu_fwcfg_find_file("etc/table-loader");
+ file = qemu_fwcfg_find_file(dev, "etc/table-loader");
if (!file) {
printf("error: can't find etc/table-loader\n");
return addr;
@@ -180,24 +191,24 @@ ulong write_acpi_tables(ulong addr)
return addr;
}
- qemu_fwcfg_read_entry(be16_to_cpu(file->cfg.select),
+ qemu_fwcfg_read_entry(dev, be16_to_cpu(file->cfg.select),
size, table_loader);
for (i = 0; i < (size / sizeof(*entry)); i++) {
entry = table_loader + i;
switch (le32_to_cpu(entry->command)) {
case BIOS_LINKER_LOADER_COMMAND_ALLOCATE:
- ret = bios_linker_allocate(entry, &addr);
+ ret = bios_linker_allocate(dev, entry, &addr);
if (ret)
goto out;
break;
case BIOS_LINKER_LOADER_COMMAND_ADD_POINTER:
- ret = bios_linker_add_pointer(entry);
+ ret = bios_linker_add_pointer(dev, entry);
if (ret)
goto out;
break;
case BIOS_LINKER_LOADER_COMMAND_ADD_CHECKSUM:
- ret = bios_linker_add_checksum(entry);
+ ret = bios_linker_add_checksum(dev, entry);
if (ret)
goto out;
break;
@@ -209,7 +220,7 @@ ulong write_acpi_tables(ulong addr)
out:
if (ret) {
struct fw_cfg_file_iter iter;
- for (file = qemu_fwcfg_file_iter_init(&iter);
+ for (file = qemu_fwcfg_file_iter_init(dev, &iter);
!qemu_fwcfg_file_iter_end(&iter);
file = qemu_fwcfg_file_iter_next(&iter)) {
if (file->addr) {
@@ -226,31 +237,91 @@ out:
ulong acpi_get_rsdp_addr(void)
{
struct fw_file *file;
+ struct udevice *dev;
- file = qemu_fwcfg_find_file("etc/acpi/rsdp");
+ dev = qemu_fwcfg_dev();
+ if (!dev) {
+ printf("error: no qfw\n");
+ return 0;
+ }
+
+ file = qemu_fwcfg_find_file(dev, "etc/acpi/rsdp");
return file->addr;
}
#endif
-/* Read configuration item using fw_cfg PIO interface */
-static void qemu_fwcfg_read_entry_pio(uint16_t entry,
- uint32_t size, void *address)
+/* Read configuration item using fw_cfg PIO/MMIO interface */
+static void qemu_fwcfg_read_entry_pio(struct qfw_plat *plat, u16 entry,
+ u32 size, void *address)
As this is not PIO only maybe qemu_fwcfg_read_entry_io().
Best regards
Heinrich
{
debug("qemu_fwcfg_read_entry_pio: entry 0x%x, size %u address %p\n",
entry, size, address);
- return fwcfg_arch_ops->arch_read_pio(entry, size, address);
+ /*
+ * writing FW_CFG_INVALID will cause read operation to resume at last
+ * offset, otherwise read will start at offset 0
+ *
+ * Note: on platform where the control register is IO port, the
+ * endianness is little endian. Where it is on MMIO, the register is
+ * big endian.
+ */
+ if (entry != FW_CFG_INVALID) {
+ if (plat->mmio)
+ plat->mmio->selector = cpu_to_be16(entry);
+#ifdef CONFIG_X86
+ else
+ outw(cpu_to_le16(entry), plat->io.control_port);
+#endif
+ }
+
+ /* the endianness of data register is string-preserving */
+
+ if (plat->mmio) {
+ while (size >= 8) {
+ *(u64 *)address = plat->mmio->data64;
+ address += 8;
+ size -= 8;
+ }
+ while (size >= 4) {
+ *(u32 *)address = plat->mmio->data32;
+ address += 4;
+ size -= 4;
+ }
+ while (size >= 2) {
+ *(u16 *)address = plat->mmio->data16;
+ address += 2;
+ size -= 2;
+ }
+ while (size >= 1) {
+ *(u8 *)address = plat->mmio->data8;
+ address += 1;
+ size -= 1;
+ }
+ }
+#ifdef CONFIG_X86
+ else {
+ u32 i = 0;
+ u8 *data = address;
+
+ while (size--)
+ data[i++] = inb(plat->io.data_port);
+ }
+#endif
}
/* Read configuration item using fw_cfg DMA interface */
-static void qemu_fwcfg_read_entry_dma(uint16_t entry,
- uint32_t size, void *address)
+static void qemu_fwcfg_read_entry_dma(struct qfw_plat *plat, u16 entry,
+ u32 size, void *address)
{
- struct fw_cfg_dma_access dma;
-
- dma.length = cpu_to_be32(size);
- dma.address = cpu_to_be64((uintptr_t)address);
- dma.control = cpu_to_be32(FW_CFG_DMA_READ);
+ struct {
+ __be32 control;
+ __be32 length;
+ __be64 address;
+ } dma = {
+ .length = cpu_to_be32(size),
+ .address = cpu_to_be64((uintptr_t)address),
+ .control = cpu_to_be32(FW_CFG_DMA_READ),
+ };
/*
* writting FW_CFG_INVALID will cause read operation to resume at
@@ -264,51 +335,58 @@ static void qemu_fwcfg_read_entry_dma(uint16_t entry,
debug("qemu_fwcfg_read_entry_dma: entry 0x%x, size %u address %p, control
0x%x\n",
entry, size, address, be32_to_cpu(dma.control));
- fwcfg_arch_ops->arch_read_dma(&dma);
-}
+ /* the DMA address register is big-endian */
+ if (plat->mmio)
+ plat->mmio->dma = cpu_to_be64((uintptr_t)&dma);
+#ifdef CONFIG_X86
+ else
+ outl(cpu_to_be32((uintptr_t)&dma), plat->io.dma_port_high);
+#endif
-bool qemu_fwcfg_present(void)
-{
- return fwcfg_present;
-}
-bool qemu_fwcfg_dma_present(void)
-{
- return fwcfg_dma_present;
+ while (be32_to_cpu(dma.control) & ~FW_CFG_DMA_ERROR)
+#ifdef CONFIG_X86
+ __asm__ __volatile__ ("pause");
+#else
+ __asm__ __volatile__ ("yield");
+#endif
}
-void qemu_fwcfg_read_entry(uint16_t entry, uint32_t length, void *address)
+void qemu_fwcfg_read_entry(struct udevice *dev, u16 entry, u32 length,
+ void *address)
{
- if (fwcfg_dma_present)
- qemu_fwcfg_read_entry_dma(entry, length, address);
+ struct qfw_plat *plat = dev_get_plat(dev);
+ struct qfw_priv *priv = dev_get_priv(dev);
+
+ if (priv->dma_present)
+ qemu_fwcfg_read_entry_dma(plat, entry, length, address);
else
- qemu_fwcfg_read_entry_pio(entry, length, address);
+ qemu_fwcfg_read_entry_pio(plat, entry, length, address);
}
-int qemu_fwcfg_online_cpus(void)
+int qemu_fwcfg_online_cpus(struct udevice *dev)
{
- uint16_t nb_cpus;
-
- if (!fwcfg_present)
- return -ENODEV;
+ u16 nb_cpus;
- qemu_fwcfg_read_entry(FW_CFG_NB_CPUS, 2, &nb_cpus);
+ qemu_fwcfg_read_entry(dev, FW_CFG_NB_CPUS, 2, &nb_cpus);
return le16_to_cpu(nb_cpus);
}
-int qemu_fwcfg_read_firmware_list(void)
+int qemu_fwcfg_read_firmware_list(struct udevice *dev)
{
int i;
- uint32_t count;
+ u32 count;
struct fw_file *file;
struct list_head *entry;
+ struct qfw_priv *priv = dev_get_priv(dev);
+
/* don't read it twice */
- if (!list_empty(&fw_list))
+ if (!list_empty(&priv->fw_list))
return 0;
- qemu_fwcfg_read_entry(FW_CFG_FILE_DIR, 4, &count);
+ qemu_fwcfg_read_entry(dev, FW_CFG_FILE_DIR, 4, &count);
if (!count)
return 0;
@@ -319,16 +397,16 @@ int qemu_fwcfg_read_firmware_list(void)
printf("error: allocating resource\n");
goto err;
}
- qemu_fwcfg_read_entry(FW_CFG_INVALID,
+ qemu_fwcfg_read_entry(dev, FW_CFG_INVALID,
sizeof(struct fw_cfg_file), &file->cfg);
file->addr = 0;
- list_add_tail(&file->list, &fw_list);
+ list_add_tail(&file->list, &priv->fw_list);
}
return 0;
err:
- list_for_each(entry, &fw_list) {
+ list_for_each(entry, &priv->fw_list) {
file = list_entry(entry, struct fw_file, list);
free(file);
}
@@ -336,12 +414,14 @@ err:
return -ENOMEM;
}
-struct fw_file *qemu_fwcfg_find_file(const char *name)
+struct fw_file *qemu_fwcfg_find_file(struct udevice *dev, const char *name)
{
struct list_head *entry;
struct fw_file *file;
- list_for_each(entry, &fw_list) {
+ struct qfw_priv *priv = dev_get_priv(dev);
+
+ list_for_each(entry, &priv->fw_list) {
file = list_entry(entry, struct fw_file, list);
if (!strcmp(file->cfg.name, name))
return file;
@@ -350,9 +430,13 @@ struct fw_file *qemu_fwcfg_find_file(const char *name)
return NULL;
}
-struct fw_file *qemu_fwcfg_file_iter_init(struct fw_cfg_file_iter *iter)
+struct fw_file *qemu_fwcfg_file_iter_init(struct udevice *dev,
+ struct fw_cfg_file_iter *iter)
{
- iter->entry = fw_list.next;
+ struct qfw_priv *priv = dev_get_priv(dev);
+
+ iter->entry = priv->fw_list.next;
+ iter->end = &priv->fw_list;
return list_entry((struct list_head *)iter->entry,
struct fw_file, list);
}
@@ -366,29 +450,62 @@ struct fw_file *qemu_fwcfg_file_iter_next(struct
fw_cfg_file_iter *iter)
bool qemu_fwcfg_file_iter_end(struct fw_cfg_file_iter *iter)
{
- return iter->entry == &fw_list;
+ return iter->entry == iter->end;
}
-void qemu_fwcfg_init(struct fw_cfg_arch_ops *ops)
+static int qfw_of_to_plat(struct udevice *dev)
{
- uint32_t qemu;
- uint32_t dma_enabled;
-
- fwcfg_present = false;
- fwcfg_dma_present = false;
- fwcfg_arch_ops = NULL;
-
- if (!ops || !ops->arch_read_pio || !ops->arch_read_dma)
- return;
- fwcfg_arch_ops = ops;
-
- qemu_fwcfg_read_entry_pio(FW_CFG_SIGNATURE, 4, &qemu);
- if (be32_to_cpu(qemu) == QEMU_FW_CFG_SIGNATURE)
- fwcfg_present = true;
-
- if (fwcfg_present) {
- qemu_fwcfg_read_entry_pio(FW_CFG_ID, 1, &dma_enabled);
- if (dma_enabled & FW_CFG_DMA_ENABLED)
- fwcfg_dma_present = true;
- }
+ struct qfw_plat *plat = dev_get_plat(dev);
+
+ plat->mmio = map_physmem(dev_read_addr(dev),
+ sizeof(struct qfw_mmio),
+ MAP_NOCACHE);
+
+ return 0;
+}
+
+static int qfw_probe(struct udevice *dev)
+{
+ u32 qemu, dma_enabled;
+ struct qfw_plat *plat = dev_get_plat(dev);
+ struct qfw_priv *priv = dev_get_priv(dev);
+
+ INIT_LIST_HEAD(&priv->fw_list);
+
+ qemu_fwcfg_read_entry_pio(plat, FW_CFG_SIGNATURE, 4, &qemu);
+ if (be32_to_cpu(qemu) != QEMU_FW_CFG_SIGNATURE)
+ return -ENODEV;
+
+ qemu_fwcfg_read_entry_pio(plat, FW_CFG_ID, 1, &dma_enabled);
+ if (dma_enabled & FW_CFG_DMA_ENABLED)
+ priv->dma_present = true;
+
+ return 0;
+}
+
+static const struct udevice_id qfw_ids[] = {
+ { .compatible = "qemu,fw-cfg-mmio" },
+ {}
+};
+
+U_BOOT_DRIVER(qfw) = {
+ .name = "qfw",
+ .id = UCLASS_MISC,
+ .of_match = qfw_ids,
+ .of_to_plat = qfw_of_to_plat,
+ .plat_auto = sizeof(struct qfw_plat),
+ .priv_auto = sizeof(struct qfw_priv),
+ .probe = qfw_probe,
+};
+
+struct udevice *qemu_fwcfg_dev(void)
+{
+ struct udevice *dev;
+ int ret;
+
+ /* XXX: decide what to do here */
+ ret = uclass_first_device(UCLASS_MISC, &dev);
+ if (ret)
+ return NULL;
+ return dev;
}
diff --git a/include/qfw.h b/include/qfw.h
index cea8e11d44..f9c6828841 100644
--- a/include/qfw.h
+++ b/include/qfw.h
@@ -82,19 +82,7 @@ struct fw_file {
};
struct fw_cfg_file_iter {
- struct list_head *entry; /* structure to iterate file list */
-};
-
-struct fw_cfg_dma_access {
- __be32 control;
- __be32 length;
- __be64 address;
-};
-
-struct fw_cfg_arch_ops {
- void (*arch_read_pio)(uint16_t selector, uint32_t size,
- void *address);
- void (*arch_read_dma)(struct fw_cfg_dma_access *dma);
+ struct list_head *entry, *end; /* structures to iterate file list */
};
struct bios_linker_entry {
@@ -146,32 +134,59 @@ struct bios_linker_entry {
};
} __packed;
+struct qfw_mmio {
+ /*
+ * Each access to the 64-bit data register can be 8/16/32/64 bits wide.
+ */
+ union {
+ u8 data8;
+ u16 data16;
+ u32 data32;
+ u64 data64;
+ };
+ u16 selector;
+ u8 padding[6];
+ u64 dma;
+};
+
+struct qfw_plat {
+ /* MMIO used on Arm. */
+ volatile struct qfw_mmio *mmio;
+ /* IO used on x86. */
+ struct {
+ u16 control_port;
+ u16 data_port;
+ u16 dma_port_low;
+ u16 dma_port_high;
+ } io;
+};
+
+struct udevice;
/**
- * Initialize QEMU fw_cfg interface
+ * Get QEMU firmware config device
*
- * @ops: arch specific read operations
+ * @return struct udevice * if present, NULL otherwise
*/
-void qemu_fwcfg_init(struct fw_cfg_arch_ops *ops);
+struct udevice *qemu_fwcfg_dev(void);
-void qemu_fwcfg_read_entry(uint16_t entry, uint32_t length, void *address);
-int qemu_fwcfg_read_firmware_list(void);
-struct fw_file *qemu_fwcfg_find_file(const char *name);
+void qemu_fwcfg_read_entry(struct udevice *dev, u16 entry, u32 length,
+ void *address);
+int qemu_fwcfg_read_firmware_list(struct udevice *dev);
+struct fw_file *qemu_fwcfg_find_file(struct udevice *dev, const char *name);
/**
* Get system cpu number
*
* @return: cpu number in system
*/
-int qemu_fwcfg_online_cpus(void);
+int qemu_fwcfg_online_cpus(struct udevice *dev);
/* helper functions to iterate firmware file list */
-struct fw_file *qemu_fwcfg_file_iter_init(struct fw_cfg_file_iter *iter);
+struct fw_file *qemu_fwcfg_file_iter_init(struct udevice *dev,
+ struct fw_cfg_file_iter *iter);
struct fw_file *qemu_fwcfg_file_iter_next(struct fw_cfg_file_iter *iter);
bool qemu_fwcfg_file_iter_end(struct fw_cfg_file_iter *iter);
-bool qemu_fwcfg_present(void);
-bool qemu_fwcfg_dma_present(void);
-
/**
* qemu_cpu_fixup() - Fix up the CPUs for QEMU
*
