Re: [U-Boot] [PATCH 05/12] x86: qemu: split qfw command interface and qfw core

Hi Miao,

On Fri, May 13, 2016 at 2:29 PM, Miao Yan yanmiaobest@gmail.com wrote:

This patch splits qfw command interface and qfw core function into two files, and introduces a new Kconfig option (CONFIG_QFW). for qfw core.

Now when qfw command interface is enabled, it will automatically select qfw core. This patch also makes the ACPI table generation select CONFIG_QFW.

Signed-off-by: Miao Yan yanmiaobest@gmail.com

arch/x86/Kconfig | 2 +- arch/x86/cpu/mp_init.c | 6 +- arch/x86/cpu/qemu/Makefile | 3 +- arch/x86/cpu/qemu/acpi_table.c | 2 + arch/x86/cpu/qemu/qemu.c | 4 + cmd/Kconfig | 1 + cmd/Makefile | 2 +- cmd/cmd_qfw.c | 182 +++++++++++++++++++++ cmd/qemu_fw_cfg.c | 353 ----------------------------------------- common/Kconfig | 1 + drivers/misc/Kconfig | 6 + drivers/misc/Makefile | 1 + drivers/misc/qemu_fw_cfg.c | 185 +++++++++++++++++++++ 13 files changed, 390 insertions(+), 358 deletions(-) create mode 100644 cmd/cmd_qfw.c delete mode 100644 cmd/qemu_fw_cfg.c create mode 100644 drivers/misc/qemu_fw_cfg.c

diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index a60e0da..2f63170 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -436,7 +436,7 @@ config GENERATE_MP_TABLE config GENERATE_ACPI_TABLE bool "Generate an ACPI (Advanced Configuration and Power Interface) table" default n

•   select QEMU_FW_CFG if QEMU
  

•   select QFW if QEMU
    help
      The Advanced Configuration and Power Interface (ACPI) specification
      provides an open standard for device configuration and management
  

diff --git a/arch/x86/cpu/mp_init.c b/arch/x86/cpu/mp_init.c index 13bec7a..109b3d7 100644 --- a/arch/x86/cpu/mp_init.c +++ b/arch/x86/cpu/mp_init.c @@ -11,7 +11,9 @@ #include <dm.h> #include <errno.h> #include <malloc.h> +#ifdef CONFIG_QFW #include <qemu_fw_cfg.h> +#endif

There is no need to wrap header file with #ifdef.

#include <asm/atomic.h> #include <asm/cpu.h> #include <asm/interrupt.h> @@ -420,7 +422,7 @@ static int init_bsp(struct udevice **devp) return 0; }

-#ifdef CONFIG_QEMU +#ifdef CONFIG_QFW static int qemu_cpu_fixup(void) { int ret; @@ -496,7 +498,7 @@ int mp_init(struct mp_params *p) if (ret) return ret;

-#ifdef CONFIG_QEMU +#ifdef CONFIG_QFW ret = qemu_cpu_fixup(); if (ret) return ret; diff --git a/arch/x86/cpu/qemu/Makefile b/arch/x86/cpu/qemu/Makefile index 43ee4bd..7c08c3d 100644 --- a/arch/x86/cpu/qemu/Makefile +++ b/arch/x86/cpu/qemu/Makefile @@ -7,5 +7,6 @@ ifndef CONFIG_EFI_STUB obj-y += car.o dram.o endif -obj-y += cpu.o qemu.o +obj-y += qemu.o +obj-$(CONFIG_QFW) += cpu.o obj-$(CONFIG_GENERATE_ACPI_TABLE) += acpi_table.o diff --git a/arch/x86/cpu/qemu/acpi_table.c b/arch/x86/cpu/qemu/acpi_table.c index b17fa03..4584fc7 100644 --- a/arch/x86/cpu/qemu/acpi_table.c +++ b/arch/x86/cpu/qemu/acpi_table.c @@ -8,7 +8,9 @@ #include <command.h> #include <errno.h> #include <malloc.h> +#ifdef CONFIG_QFW #include <qemu_fw_cfg.h> +#endif

ditto.

#include <asm/io.h> #include <asm/tables.h> #include <asm/e820.h> diff --git a/arch/x86/cpu/qemu/qemu.c b/arch/x86/cpu/qemu/qemu.c index b41e4ec..2631e99 100644 --- a/arch/x86/cpu/qemu/qemu.c +++ b/arch/x86/cpu/qemu/qemu.c @@ -6,7 +6,9 @@

#include <common.h> #include <pci.h> +#ifdef CONFIG_QFW #include <qemu_fw_cfg.h> +#endif

ditto.

#include <asm/irq.h> #include <asm/post.h> #include <asm/processor.h> @@ -88,7 +90,9 @@ static void qemu_chipset_init(void) enable_pm_ich9(); }

+#ifdef CONFIG_QFW qemu_fwcfg_init(); +#endif }

int arch_cpu_init(void) diff --git a/cmd/Kconfig b/cmd/Kconfig index c0fffe3..08b761f 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -596,6 +596,7 @@ config CMD_SOUND config CMD_QEMU_FW_CFG bool "qfw" depends on X86

•   select QFW
    help
      This provides access to the QEMU firmware interface.  The main
      feature is to allow easy loading of files passed to qemu-system
  

diff --git a/cmd/Makefile b/cmd/Makefile index f99e67d..31e4da7 100644 --- a/cmd/Makefile +++ b/cmd/Makefile @@ -105,7 +105,7 @@ endif obj-y += pcmcia.o obj-$(CONFIG_CMD_PORTIO) += portio.o obj-$(CONFIG_CMD_PXE) += pxe.o -obj-$(CONFIG_CMD_QEMU_FW_CFG) += qemu_fw_cfg.o +obj-$(CONFIG_CMD_QEMU_FW_CFG) += cmd_qfw.o obj-$(CONFIG_CMD_READ) += read.o obj-$(CONFIG_CMD_REGINFO) += reginfo.o obj-$(CONFIG_CMD_REISER) += reiser.o diff --git a/cmd/cmd_qfw.c b/cmd/cmd_qfw.c new file mode 100644 index 0000000..eefaf65 --- /dev/null +++ b/cmd/cmd_qfw.c @@ -0,0 +1,182 @@ +/*

• • (C) Copyright 2015 Miao Yan yanmiaobest@gmail.com
• • SPDX-License-Identifier: GPL-2.0+
• */

+#include <common.h> +#include <command.h> +#include <errno.h> +#include <qemu_fw_cfg.h>

+/*

• • 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) +{

•   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);
  

•   if (setup_size == 0 || kernel_size == 0) {
  

•           printf("warning: no kernel available\n");
  

•           return -1;
  

•   }
  

•   data_addr = load_addr;
  

•   qemu_fwcfg_read_entry(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,
  

•                         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);
  

•   if (initrd_size == 0) {
  

•           printf("warning: no initrd available\n");
  

•   } else {
  

•           qemu_fwcfg_read_entry(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);
  

•   if (cmdline_size) {
  

•           qemu_fwcfg_read_entry(FW_CFG_CMDLINE_DATA,
  

•                                 le32_to_cpu(cmdline_size), data_addr);
  

•           /*
  

•            * if kernel cmdline only contains '\0', (e.g. no -append
  

•            * when invoking qemu), do not update bootargs
  

•            */
  

•           if (*data_addr != '\0') {
  

•                   if (setenv("bootargs", data_addr) < 0)
  

•                           printf("warning: unable to change bootargs\n");
  

•           }
  

•   }
  

•   printf("loading kernel to address %p size %x", load_addr,
  

•          le32_to_cpu(kernel_size));
  

•   if (initrd_size)
  

•           printf(" initrd %p size %x\n",
  

•                  initrd_addr,
  

•                  le32_to_cpu(initrd_size));
  

•   else
  

•           printf("\n");
  

•   return 0;
  

+}

+static int qemu_fwcfg_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();
  

•   if (ret)
  

•           return ret;
  

•   for (file = qemu_fwcfg_file_iter_init(&iter);
  

•        !qemu_fwcfg_file_iter_end(&iter);
  

•        file = qemu_fwcfg_file_iter_next(&iter)) {
  

•           printf("%-56s\n", file->cfg.name);
  

•   }
  

•   return 0;
  

+}

+static int qemu_fwcfg_do_list(cmd_tbl_t *cmdtp, int flag,

•           int argc, char * const argv[])
  

+{

•   if (qemu_fwcfg_list_firmware() < 0)
  

•           return CMD_RET_FAILURE;
  

•   return 0;
  

+}

+static int qemu_fwcfg_do_cpus(cmd_tbl_t *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());
  

•   return 0;
  

+}

+static int qemu_fwcfg_do_load(cmd_tbl_t *cmdtp, int flag,

•           int argc, char * const argv[])
  

+{

•   char *env;
  

•   void *load_addr;
  

•   void *initrd_addr;
  

•   env = getenv("loadaddr");
  

•   load_addr = env ?
  

•           (void *)simple_strtoul(env, NULL, 16) :
  

•           (void *)CONFIG_LOADADDR;
  

•   env = getenv("ramdiskaddr");
  

•   initrd_addr = env ?
  

•           (void *)simple_strtoul(env, NULL, 16) :
  

•           (void *)CONFIG_RAMDISK_ADDR;
  

•   if (argc == 2) {
  

•           load_addr = (void *)simple_strtoul(argv[0], NULL, 16);
  

•           initrd_addr = (void *)simple_strtoul(argv[1], NULL, 16);
  

•   } else if (argc == 1) {
  

•           load_addr = (void *)simple_strtoul(argv[0], NULL, 16);
  

•   }
  

•   return qemu_fwcfg_setup_kernel(load_addr, initrd_addr);
  

+}

+static cmd_tbl_t fwcfg_commands[] = {

•   U_BOOT_CMD_MKENT(list, 0, 1, qemu_fwcfg_do_list, "", ""),
  

•   U_BOOT_CMD_MKENT(cpus, 0, 1, qemu_fwcfg_do_cpus, "", ""),
  

•   U_BOOT_CMD_MKENT(load, 2, 1, qemu_fwcfg_do_load, "", ""),
  

+};

+static int do_qemu_fw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{

•   int ret;
  

•   cmd_tbl_t *fwcfg_cmd;
  

•   if (!qemu_fwcfg_present()) {
  

•           printf("QEMU fw_cfg interface not found\n");
  

•           return CMD_RET_USAGE;
  

•   }
  

•   fwcfg_cmd = find_cmd_tbl(argv[1], fwcfg_commands,
  

•                            ARRAY_SIZE(fwcfg_commands));
  

•   argc -= 2;
  

•   argv += 2;
  

•   if (!fwcfg_cmd || argc > fwcfg_cmd->maxargs)
  

•           return CMD_RET_USAGE;
  

•   ret = fwcfg_cmd->cmd(fwcfg_cmd, flag, argc, argv);
  

•   return cmd_process_error(fwcfg_cmd, ret);
  

+}

+U_BOOT_CMD(

•   qfw,    4,      1,      do_qemu_fw,
  

•   "QEMU firmware interface",
  

•   "<command>\n"
  

•   "    - list                             : print firmware(s) currently loaded\n"
  

•   "    - cpus                             : print online cpu number\n"
  

•   "    - load <kernel addr> <initrd addr> : load kernel and initrd (if any), and setup for zboot\n"
  

+)

diff --git a/cmd/qemu_fw_cfg.c b/cmd/qemu_fw_cfg.c deleted file mode 100644 index aab6b1a..0000000 --- a/cmd/qemu_fw_cfg.c +++ /dev/null @@ -1,353 +0,0 @@ -/*

• • (C) Copyright 2015 Miao Yan yanmiaobest@gmail.com
• • SPDX-License-Identifier: GPL-2.0+
• */

-#include <common.h> -#include <command.h> -#include <errno.h> -#include <malloc.h> -#include <qemu_fw_cfg.h> -#include <asm/io.h> -#include <linux/list.h>

-static bool fwcfg_present; -static bool fwcfg_dma_present;

-static LIST_HEAD(fw_list);

-/* Read configuration item using fw_cfg PIO interface */ -static void qemu_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
  

•    */
  

•   if (entry != FW_CFG_INVALID)
  

•           outw(entry, FW_CONTROL_PORT);
  

•   while (size--)
  

•           data[i++] = inb(FW_DATA_PORT);
  

-}

-/* Read configuration item using fw_cfg DMA interface */ -static void qemu_fwcfg_read_entry_dma(uint16_t entry,

•           uint32_t 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);
  

•   /*
  

•    * writting FW_CFG_INVALID will cause read operation to resume at
  

•    * last offset, otherwise read will start at offset 0
  

•    */
  

•   if (entry != FW_CFG_INVALID)
  

•           dma.control |= cpu_to_be32(FW_CFG_DMA_SELECT | (entry << 16));
  

•   barrier();
  

•   debug("qemu_fwcfg_dma_read_entry: addr %p, length %u control 0x%x\n",
  

•         address, size, be32_to_cpu(dma.control));
  

•   outl(cpu_to_be32((uint32_t)&dma), FW_DMA_PORT_HIGH);
  

•   while (be32_to_cpu(dma.control) & ~FW_CFG_DMA_ERROR)
  

•           __asm__ __volatile__ ("pause");
  

-}

-bool qemu_fwcfg_present(void) -{

•   return fwcfg_present;
  

-}

-bool qemu_fwcfg_dma_present(void) -{

•   return fwcfg_dma_present;
  

-}

-void qemu_fwcfg_read_entry(uint16_t entry, uint32_t length, void *address) -{

•   if (fwcfg_dma_present)
  

•           qemu_fwcfg_read_entry_dma(entry, length, address);
  

•   else
  

•           qemu_fwcfg_read_entry_pio(entry, length, address);
  

-}

-int qemu_fwcfg_online_cpus(void) -{

•   uint16_t nb_cpus;
  

•   if (!fwcfg_present)
  

•           return -ENODEV;
  

•   qemu_fwcfg_read_entry(FW_CFG_NB_CPUS, 2, &nb_cpus);
  

•   return le16_to_cpu(nb_cpus);
  

-}

-/*

• • 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) -{

•   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);
  

•   if (setup_size == 0 || kernel_size == 0) {
  

•           printf("warning: no kernel available\n");
  

•           return -1;
  

•   }
  

•   data_addr = load_addr;
  

•   qemu_fwcfg_read_entry(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,
  

•                         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);
  

•   if (initrd_size == 0) {
  

•           printf("warning: no initrd available\n");
  

•   } else {
  

•           qemu_fwcfg_read_entry(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);
  

•   if (cmdline_size) {
  

•           qemu_fwcfg_read_entry(FW_CFG_CMDLINE_DATA,
  

•                                 le32_to_cpu(cmdline_size), data_addr);
  

•           /*
  

•            * if kernel cmdline only contains '\0', (e.g. no -append
  

•            * when invoking qemu), do not update bootargs
  

•            */
  

•           if (*data_addr != '\0') {
  

•                   if (setenv("bootargs", data_addr) < 0)
  

•                           printf("warning: unable to change bootargs\n");
  

•           }
  

•   }
  

•   printf("loading kernel to address %p size %x", load_addr,
  

•          le32_to_cpu(kernel_size));
  

•   if (initrd_size)
  

•           printf(" initrd %p size %x\n",
  

•                  initrd_addr,
  

•                  le32_to_cpu(initrd_size));
  

•   else
  

•           printf("\n");
  

•   return 0;
  

-}

-int qemu_fwcfg_read_firmware_list(void) -{

•   int i;
  

•   uint32_t count;
  

•   struct fw_file *file;
  

•   struct list_head *entry;
  

•   /* don't read it twice */
  

•   if (!list_empty(&fw_list))
  

•           return 0;
  

•   qemu_fwcfg_read_entry(FW_CFG_FILE_DIR, 4, &count);
  

•   if (!count)
  

•           return 0;
  

•   count = be32_to_cpu(count);
  

•   for (i = 0; i < count; i++) {
  

•           file = malloc(sizeof(*file));
  

•           if (!file) {
  

•                   printf("error: allocating resource\n");
  

•                   goto err;
  

•           }
  

•           qemu_fwcfg_read_entry(FW_CFG_INVALID,
  

•                                 sizeof(struct fw_cfg_file), &file->cfg);
  

•           file->addr = 0;
  

•           list_add_tail(&file->list, &fw_list);
  

•   }
  

•   return 0;
  

-err:

•   list_for_each(entry, &fw_list) {
  

•           file = list_entry(entry, struct fw_file, list);
  

•           free(file);
  

•   }
  

•   return -ENOMEM;
  

-}

-struct fw_file *qemu_fwcfg_find_file(const char *name) -{

•   struct list_head *entry;
  

•   struct fw_file *file;
  

•   list_for_each(entry, &fw_list) {
  

•           file = list_entry(entry, struct fw_file, list);
  

•           if (!strcmp(file->cfg.name, name))
  

•                   return file;
  

•   }
  

•   return NULL;
  

-}

-struct fw_file *qemu_fwcfg_file_iter_init(struct fw_cfg_file_iter *iter) -{

•   iter->entry = fw_list.next;
  

•   return list_entry(iter->entry, struct fw_file, list);
  

-}

-struct fw_file *qemu_fwcfg_file_iter_next(struct fw_cfg_file_iter *iter) -{

•   iter->entry = iter->entry->next;
  

•   return list_entry(iter->entry, struct fw_file, list);
  

-}

-bool qemu_fwcfg_file_iter_end(struct fw_cfg_file_iter *iter) -{

•   return iter->entry == &fw_list;
  

-}

-static int qemu_fwcfg_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();
  

•   if (ret)
  

•           return ret;
  

•   for (file = qemu_fwcfg_file_iter_init(&iter);
  

•        !qemu_fwcfg_file_iter_end(&iter);
  

•        file = qemu_fwcfg_file_iter_next(&iter)) {
  

•           printf("%-56s\n", file->cfg.name);
  

•   }
  

•   return 0;
  

-}

-void qemu_fwcfg_init(void) -{

•   uint32_t qemu;
  

•   uint32_t dma_enabled;
  

•   fwcfg_present = false;
  

•   fwcfg_dma_present = false;
  

•   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;
  

•   }
  

-}

-static int qemu_fwcfg_do_list(cmd_tbl_t *cmdtp, int flag,

•           int argc, char * const argv[])
  

-{

•   if (qemu_fwcfg_list_firmware() < 0)
  

•           return CMD_RET_FAILURE;
  

•   return 0;
  

-}

-static int qemu_fwcfg_do_cpus(cmd_tbl_t *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());
  

•   return 0;
  

-}

-static int qemu_fwcfg_do_load(cmd_tbl_t *cmdtp, int flag,

•           int argc, char * const argv[])
  

-{

•   char *env;
  

•   void *load_addr;
  

•   void *initrd_addr;
  

•   env = getenv("loadaddr");
  

•   load_addr = env ?
  

•           (void *)simple_strtoul(env, NULL, 16) :
  

•           (void *)CONFIG_LOADADDR;
  

•   env = getenv("ramdiskaddr");
  

•   initrd_addr = env ?
  

•           (void *)simple_strtoul(env, NULL, 16) :
  

•           (void *)CONFIG_RAMDISK_ADDR;
  

•   if (argc == 2) {
  

•           load_addr = (void *)simple_strtoul(argv[0], NULL, 16);
  

•           initrd_addr = (void *)simple_strtoul(argv[1], NULL, 16);
  

•   } else if (argc == 1) {
  

•           load_addr = (void *)simple_strtoul(argv[0], NULL, 16);
  

•   }
  

•   return qemu_fwcfg_setup_kernel(load_addr, initrd_addr);
  

-}

-static cmd_tbl_t fwcfg_commands[] = {

•   U_BOOT_CMD_MKENT(list, 0, 1, qemu_fwcfg_do_list, "", ""),
  

•   U_BOOT_CMD_MKENT(cpus, 0, 1, qemu_fwcfg_do_cpus, "", ""),
  

•   U_BOOT_CMD_MKENT(load, 2, 1, qemu_fwcfg_do_load, "", ""),
  

-};

-static int do_qemu_fw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) -{

•   int ret;
  

•   cmd_tbl_t *fwcfg_cmd;
  

•   if (!qemu_fwcfg_present()) {
  

•           printf("QEMU fw_cfg interface not found\n");
  

•           return CMD_RET_USAGE;
  

•   }
  

•   fwcfg_cmd = find_cmd_tbl(argv[1], fwcfg_commands,
  

•                            ARRAY_SIZE(fwcfg_commands));
  

•   argc -= 2;
  

•   argv += 2;
  

•   if (!fwcfg_cmd || argc > fwcfg_cmd->maxargs)
  

•           return CMD_RET_USAGE;
  

•   ret = fwcfg_cmd->cmd(fwcfg_cmd, flag, argc, argv);
  

•   return cmd_process_error(fwcfg_cmd, ret);
  

-}

-U_BOOT_CMD(

•   qfw,    4,      1,      do_qemu_fw,
  

•   "QEMU firmware interface",
  

•   "<command>\n"
  

•   "    - list                             : print firmware(s) currently loaded\n"
  

•   "    - cpus                             : print online cpu number\n"
  

•   "    - load <kernel addr> <initrd addr> : load kernel and initrd (if any), and setup for zboot\n"
  

-) diff --git a/common/Kconfig b/common/Kconfig index 067545d..8ca5a68 100644 --- a/common/Kconfig +++ b/common/Kconfig @@ -124,3 +124,4 @@ config CONSOLE_RECORD_IN_SIZE tstc() and getc() will use this in preference to real device input. The buffer is allocated immediately after the malloc() region is ready.

What is this for?

diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig index af8667f..fa53700 100644 --- a/drivers/misc/Kconfig +++ b/drivers/misc/Kconfig @@ -138,4 +138,10 @@ config WINBOND_W83627 legacy UART or other devices in the Winbond Super IO chips on X86 platforms.

+config QFW

•   bool
  

•   help
  

•     Hidden option to enable QEMU fw_cfg interface. This will be selected by
  

•     either CONFIG_CMD_QEMU_FW_CFG or CONFIG_GENERATE_ACPI_TABLE.
  

endmenu diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile index 5969d34..4893086 100644 --- a/drivers/misc/Makefile +++ b/drivers/misc/Makefile @@ -43,3 +43,4 @@ obj-$(CONFIG_PCA9551_LED) += pca9551_led.o obj-$(CONFIG_RESET) += reset-uclass.o obj-$(CONFIG_FSL_DEVICE_DISABLE) += fsl_devdis.o obj-$(CONFIG_WINBOND_W83627) += winbond_w83627.o +obj-$(CONFIG_QFW) += qemu_fw_cfg.o diff --git a/drivers/misc/qemu_fw_cfg.c b/drivers/misc/qemu_fw_cfg.c new file mode 100644 index 0000000..e726059 --- /dev/null +++ b/drivers/misc/qemu_fw_cfg.c @@ -0,0 +1,185 @@ +/*

• • (C) Copyright 2015 Miao Yan yanmiaobest@gmail.com
• • SPDX-License-Identifier: GPL-2.0+
• */

+#include <common.h> +#include <command.h> +#include <errno.h> +#include <malloc.h> +#include <qemu_fw_cfg.h> +#include <asm/io.h> +#include <linux/list.h>

+static bool fwcfg_present; +static bool fwcfg_dma_present;

+static LIST_HEAD(fw_list);

+/* Read configuration item using fw_cfg PIO interface */ +static void qemu_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
  

•    */
  

•   if (entry != FW_CFG_INVALID)
  

•           outw(entry, FW_CONTROL_PORT);
  

•   while (size--)
  

•           data[i++] = inb(FW_DATA_PORT);
  

+}

+/* Read configuration item using fw_cfg DMA interface */ +static void qemu_fwcfg_read_entry_dma(uint16_t entry,

•           uint32_t 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);
  

•   /*
  

•    * writting FW_CFG_INVALID will cause read operation to resume at
  

•    * last offset, otherwise read will start at offset 0
  

•    */
  

•   if (entry != FW_CFG_INVALID)
  

•           dma.control |= cpu_to_be32(FW_CFG_DMA_SELECT | (entry << 16));
  

•   barrier();
  

•   debug("qemu_fwcfg_dma_read_entry: addr %p, length %u control 0x%x\n",
  

•         address, size, be32_to_cpu(dma.control));
  

•   outl(cpu_to_be32((uint32_t)&dma), FW_DMA_PORT_HIGH);
  

•   while (be32_to_cpu(dma.control) & ~FW_CFG_DMA_ERROR)
  

•           __asm__ __volatile__ ("pause");
  

+}

+bool qemu_fwcfg_present(void) +{

•   return fwcfg_present;
  

+}

+bool qemu_fwcfg_dma_present(void) +{

•   return fwcfg_dma_present;
  

+}

+void qemu_fwcfg_read_entry(uint16_t entry, uint32_t length, void *address) +{

•   if (fwcfg_dma_present)
  

•           qemu_fwcfg_read_entry_dma(entry, length, address);
  

•   else
  

•           qemu_fwcfg_read_entry_pio(entry, length, address);
  

+}

+int qemu_fwcfg_online_cpus(void) +{

•   uint16_t nb_cpus;
  

•   if (!fwcfg_present)
  

•           return -ENODEV;
  

•   qemu_fwcfg_read_entry(FW_CFG_NB_CPUS, 2, &nb_cpus);
  

•   return le16_to_cpu(nb_cpus);
  

+}

+int qemu_fwcfg_read_firmware_list(void) +{

•   int i;
  

•   uint32_t count;
  

•   struct fw_file *file;
  

•   struct list_head *entry;
  

•   /* don't read it twice */
  

•   if (!list_empty(&fw_list))
  

•           return 0;
  

•   qemu_fwcfg_read_entry(FW_CFG_FILE_DIR, 4, &count);
  

•   if (!count)
  

•           return 0;
  

•   count = be32_to_cpu(count);
  

•   for (i = 0; i < count; i++) {
  

•           file = malloc(sizeof(*file));
  

•           if (!file) {
  

•                   printf("error: allocating resource\n");
  

•                   goto err;
  

•           }
  

•           qemu_fwcfg_read_entry(FW_CFG_INVALID,
  

•                                 sizeof(struct fw_cfg_file), &file->cfg);
  

•           file->addr = 0;
  

•           list_add_tail(&file->list, &fw_list);
  

•   }
  

•   return 0;
  

+err:

•   list_for_each(entry, &fw_list) {
  

•           file = list_entry(entry, struct fw_file, list);
  

•           free(file);
  

•   }
  

•   return -ENOMEM;
  

+}

+struct fw_file *qemu_fwcfg_find_file(const char *name) +{

•   struct list_head *entry;
  

•   struct fw_file *file;
  

•   list_for_each(entry, &fw_list) {
  

•           file = list_entry(entry, struct fw_file, list);
  

•           if (!strcmp(file->cfg.name, name))
  

•                   return file;
  

•   }
  

•   return NULL;
  

+}

+struct fw_file *qemu_fwcfg_file_iter_init(struct fw_cfg_file_iter *iter) +{

•   iter->entry = fw_list.next;
  

•   return list_entry((struct list_head *)iter->entry,
  

•                     struct fw_file, list);
  

+}

+struct fw_file *qemu_fwcfg_file_iter_next(struct fw_cfg_file_iter *iter) +{

•   iter->entry = ((struct list_head *)iter->entry)->next;
  

•   return list_entry((struct list_head *)iter->entry,
  

•                     struct fw_file, list);
  

+}

+bool qemu_fwcfg_file_iter_end(struct fw_cfg_file_iter *iter) +{

•   return iter->entry == &fw_list;
  

+}

+void qemu_fwcfg_init(void) +{

•   uint32_t qemu;
  

•   uint32_t dma_enabled;
  

•   fwcfg_present = false;
  

•   fwcfg_dma_present = false;
  

•   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;
  

•   }
  

+}

--

When applying this patch, I got:

$ git am U-Boot-05-12-x86-qemu-split-qfw-command-interface-and-qfw-core.patch Applying: x86: qemu: split qfw command interface and qfw core /git/u-boot/.git/rebase-apply/patch:327: new blank line at EOF. + /git/u-boot/.git/rebase-apply/patch:695: new blank line at EOF. + /git/u-boot/.git/rebase-apply/patch:910: new blank line at EOF. + warning: 3 lines add whitespace errors.

Can you please fix these?

Regards, Bin