Merge branch 'next'

34 files changed, 2741 insertions, 64 deletions

diff --git a/cmd/Kconfig b/cmd/Kconfig
index 0e0be94f41f..bfa12ce12a7 100644
--- a/cmd/Kconfig
+++ b/cmd/Kconfig
@@ -1092,7 +1092,6 @@ config CMD_PWM
 config CMD_GPT
 	bool "GPT (GUID Partition Table) command"
 	select EFI_PARTITION
-	select HAVE_BLOCK_DEVICE
 	select PARTITION_UUIDS
 	imply RANDOM_UUID
 	help
@@ -1194,6 +1193,13 @@ config CMD_LOADS
 	help
 	  Load an S-Record file over serial line
 
+config CMD_LOADXY_TIMEOUT
+	int "loadxy_timeout"
+	range 0 2000
+	default 90
+	help
+	  Initial timeout for loadx and loady commands. Zero means infinity.
+
 config CMD_LSBLK
 	depends on BLK
 	bool "lsblk - list block drivers and devices"
@@ -1204,7 +1210,6 @@ config CMD_LSBLK
 config CMD_MBR
 	bool "MBR (Master Boot Record) command"
 	select DOS_PARTITION
-	select HAVE_BLOCK_DEVICE
 	help
 	  Enable the 'mbr' command to ready and write MBR (Master Boot Record)
 	  style partition tables.
@@ -1336,7 +1341,6 @@ config CMD_OSD
 config CMD_PART
 	bool "part"
 	depends on PARTITIONS
-	select HAVE_BLOCK_DEVICE
 	select PARTITION_UUIDS
 	help
 	  Read and display information about the partition table on
@@ -1467,7 +1471,6 @@ config CMD_UNIVERSE
 config CMD_USB
 	bool "usb"
 	depends on USB_HOST
-	select HAVE_BLOCK_DEVICE
 	help
 	  USB support.
 
@@ -1507,7 +1510,6 @@ config CMD_PVBLOCK
 config CMD_VIRTIO
 	bool "virtio"
 	depends on VIRTIO
-	depends on HAVE_BLOCK_DEVICE
 	default y if VIRTIO
 	help
 	  VirtIO block device support
@@ -1928,6 +1930,13 @@ config CMD_EFIDEBUG
 	  particularly for managing boot parameters as  well as examining
 	  various EFI status for debugging.
 
+config CMD_EFICONFIG
+	bool "eficonfig - provide menu-driven uefi variables maintenance interface"
+	depends on CMD_BOOTEFI_BOOTMGR
+	help
+	  Enable the 'eficonfig' command which provides the menu-driven UEFI
+	  variable maintenance interface.
+
 config CMD_EXCEPTION
 	bool "exception - raise exception"
 	depends on ARM || RISCV || SANDBOX || X86
@@ -1971,6 +1980,12 @@ config CMD_GETTIME
 	  milliseconds. See also the 'bootstage' command which provides more
 	  flexibility for boot timing.
 
+config CMD_PAUSE
+	bool "pause command"
+	help
+	  Delay execution waiting for any user input.
+	  Useful to allow the user to read a failure log.
+
 config CMD_RNG
 	bool "rng command"
 	depends on DM_RNG
@@ -2505,6 +2520,22 @@ config CMD_CBSYSINFO
 	  memory by coreboot before jumping to U-Boot. It can be useful for
 	  debugging the beaaviour of coreboot or U-Boot.
 
+config CMD_CYCLIC
+	bool "cyclic - Show information about cyclic functions"
+	depends on CYCLIC
+	default y
+	help
+	  This enables the 'cyclic' command which provides information about
+	  cyclic execution functions. This infrastructure allows registering
+	  functions to be executed cyclically, e.g. every 100ms. These commands
+	  are supported:
+
+	    cyclic list - list cyclic functions
+	    cyclic cyclic demo <cycletime_ms> <delay_us> - register cyclic
+		demo function
+
+	  See doc/develop/cyclic.rst for more details.
+
 config CMD_DIAG
 	bool "diag - Board diagnostics"
 	help
diff --git a/cmd/Makefile b/cmd/Makefile
index 6e87522b62e..cf6ce1bd6fd 100644
--- a/cmd/Makefile
+++ b/cmd/Makefile
@@ -18,7 +18,7 @@ obj-$(CONFIG_CMD_AES) += aes.o
 obj-$(CONFIG_CMD_AB_SELECT) += ab_select.o
 obj-$(CONFIG_CMD_ADC) += adc.o
 obj-$(CONFIG_CMD_ARMFLASH) += armflash.o
-obj-$(CONFIG_HAVE_BLOCK_DEVICE) += blk_common.o
+obj-$(CONFIG_BLK) += blk_common.o
 obj-$(CONFIG_CMD_BOOTDEV) += bootdev.o
 obj-$(CONFIG_CMD_BOOTFLOW) += bootflow.o
 obj-$(CONFIG_CMD_BOOTMETH) += bootmeth.o
@@ -56,6 +56,7 @@ obj-$(CONFIG_CMD_DIAG) += diag.o
 endif
 obj-$(CONFIG_CMD_ADTIMG) += adtimg.o
 obj-$(CONFIG_CMD_ABOOTIMG) += abootimg.o
+obj-$(CONFIG_CMD_CYCLIC) += cyclic.o
 obj-$(CONFIG_CMD_EVENT) += event.o
 obj-$(CONFIG_CMD_EXTENSION) += extension_board.o
 obj-$(CONFIG_CMD_ECHO) += echo.o
@@ -63,6 +64,7 @@ obj-$(CONFIG_ENV_IS_IN_EEPROM) += eeprom.o
 obj-$(CONFIG_CMD_EEPROM) += eeprom.o
 obj-$(CONFIG_EFI) += efi.o
 obj-$(CONFIG_CMD_EFIDEBUG) += efidebug.o
+obj-$(CONFIG_CMD_EFICONFIG) += eficonfig.o
 obj-$(CONFIG_CMD_ELF) += elf.o
 obj-$(CONFIG_CMD_EROFS) += erofs.o
 obj-$(CONFIG_HUSH_PARSER) += exit.o
@@ -102,6 +104,7 @@ obj-$(CONFIG_CMD_MFSL) += mfsl.o
 obj-$(CONFIG_CMD_MII) += mii.o
 obj-$(CONFIG_CMD_MISC) += misc.o
 obj-$(CONFIG_CMD_MDIO) += mdio.o
+obj-$(CONFIG_CMD_PAUSE) += pause.o
 obj-$(CONFIG_CMD_SLEEP) += sleep.o
 obj-$(CONFIG_CMD_MMC) += mmc.o
 obj-$(CONFIG_CMD_OPTEE_RPMB) += optee_rpmb.o
diff --git a/cmd/bcb.c b/cmd/bcb.c
index 1bbd1fae998..1622a90c97f 100644
--- a/cmd/bcb.c
+++ b/cmd/bcb.c
@@ -122,7 +122,7 @@ static int __bcb_load(int devnum, const char *partp)
 	char *endp;
 	int part, ret;
 
-	desc = blk_get_devnum_by_type(IF_TYPE_MMC, devnum);
+	desc = blk_get_devnum_by_uclass_id(UCLASS_MMC, devnum);
 	if (!desc) {
 		ret = -ENODEV;
 		goto err_read_fail;
@@ -287,7 +287,7 @@ static int __bcb_store(void)
 	u64 cnt;
 	int ret;
 
-	desc = blk_get_devnum_by_type(IF_TYPE_MMC, bcb_dev);
+	desc = blk_get_devnum_by_uclass_id(UCLASS_MMC, bcb_dev);
 	if (!desc) {
 		ret = -ENODEV;
 		goto err;
diff --git a/cmd/bdinfo.c b/cmd/bdinfo.c
index 37cd8a57ebd..af2e9757db5 100644
--- a/cmd/bdinfo.c
+++ b/cmd/bdinfo.c
@@ -16,9 +16,16 @@
 #include <vsprintf.h>
 #include <asm/cache.h>
 #include <asm/global_data.h>
+#include <display_options.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 
+void bdinfo_print_size(const char *name, uint64_t size)
+{
+	printf("%-12s= ", name);
+	print_size(size, "\n");
+}
+
 void bdinfo_print_num_l(const char *name, ulong value)
 {
 	printf("%-12s= 0x%0*lx\n", name, 2 * (int)sizeof(value), value);
@@ -123,7 +130,7 @@ int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 #if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
 	bdinfo_print_num_l("multi_dtb_fit", (ulong)gd->multi_dtb_fit);
 #endif
-	if (gd->fdt_blob) {
+	if (IS_ENABLED(CONFIG_LMB) && gd->fdt_blob) {
 		struct lmb lmb;
 
 		lmb_init_and_reserve(&lmb, gd->bd, (void *)gd->fdt_blob);
diff --git a/cmd/blk_common.c b/cmd/blk_common.c
index 4e442f2918b..75a072caf51 100644
--- a/cmd/blk_common.c
+++ b/cmd/blk_common.c
@@ -12,10 +12,10 @@
 #include <blk.h>
 #include <command.h>
 
-int blk_common_cmd(int argc, char *const argv[], enum if_type if_type,
+int blk_common_cmd(int argc, char *const argv[], enum uclass_id uclass_id,
 		   int *cur_devnump)
 {
-	const char *if_name = blk_get_if_type_name(if_type);
+	const char *if_name = blk_get_uclass_name(uclass_id);
 
 	switch (argc) {
 	case 0:
@@ -23,16 +23,16 @@ int blk_common_cmd(int argc, char *const argv[], enum if_type if_type,
 		return CMD_RET_USAGE;
 	case 2:
 		if (strncmp(argv[1], "inf", 3) == 0) {
-			blk_list_devices(if_type);
+			blk_list_devices(uclass_id);
 			return 0;
 		} else if (strncmp(argv[1], "dev", 3) == 0) {
-			if (blk_print_device_num(if_type, *cur_devnump)) {
+			if (blk_print_device_num(uclass_id, *cur_devnump)) {
 				printf("\nno %s devices available\n", if_name);
 				return CMD_RET_FAILURE;
 			}
 			return 0;
 		} else if (strncmp(argv[1], "part", 4) == 0) {
-			if (blk_list_part(if_type))
+			if (blk_list_part(uclass_id))
 				printf("\nno %s partition table available\n",
 				       if_name);
 			return 0;
@@ -42,7 +42,7 @@ int blk_common_cmd(int argc, char *const argv[], enum if_type if_type,
 		if (strncmp(argv[1], "dev", 3) == 0) {
 			int dev = (int)dectoul(argv[2], NULL);
 
-			if (!blk_show_device(if_type, dev)) {
+			if (!blk_show_device(uclass_id, dev)) {
 				*cur_devnump = dev;
 				printf("... is now current device\n");
 			} else {
@@ -52,7 +52,7 @@ int blk_common_cmd(int argc, char *const argv[], enum if_type if_type,
 		} else if (strncmp(argv[1], "part", 4) == 0) {
 			int dev = (int)dectoul(argv[2], NULL);
 
-			if (blk_print_part_devnum(if_type, dev)) {
+			if (blk_print_part_devnum(uclass_id, dev)) {
 				printf("\n%s device %d not available\n",
 				       if_name, dev);
 				return CMD_RET_FAILURE;
@@ -71,7 +71,7 @@ int blk_common_cmd(int argc, char *const argv[], enum if_type if_type,
 			printf("\n%s read: device %d block # "LBAFU", count %lu ... ",
 			       if_name, *cur_devnump, blk, cnt);
 
-			n = blk_read_devnum(if_type, *cur_devnump, blk, cnt,
+			n = blk_read_devnum(uclass_id, *cur_devnump, blk, cnt,
 					    (ulong *)addr);
 
 			printf("%ld blocks read: %s\n", n,
@@ -86,7 +86,7 @@ int blk_common_cmd(int argc, char *const argv[], enum if_type if_type,
 			printf("\n%s write: device %d block # "LBAFU", count %lu ... ",
 			       if_name, *cur_devnump, blk, cnt);
 
-			n = blk_write_devnum(if_type, *cur_devnump, blk, cnt,
+			n = blk_write_devnum(uclass_id, *cur_devnump, blk, cnt,
 					     (ulong *)addr);
 
 			printf("%ld blocks written: %s\n", n,
diff --git a/cmd/boot.c b/cmd/boot.c
index be67a5980de..14839c1cedc 100644
--- a/cmd/boot.c
+++ b/cmd/boot.c
@@ -32,6 +32,7 @@ static int do_go(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 	addr = hextoul(argv[1], NULL);
 
 	printf ("## Starting application at 0x%08lX ...\n", addr);
+	flush();
 
 	/*
 	 * pass address parameter as argv[0] (aka command name),
diff --git a/cmd/bootefi.c b/cmd/bootefi.c
index 8ab0ff5a642..3041873afbb 100644
--- a/cmd/bootefi.c
+++ b/cmd/bootefi.c
@@ -281,7 +281,7 @@ efi_status_t efi_install_fdt(void *fdt)
 		return EFI_SUCCESS;
 	}
 #else
-	bootm_headers_t img = { 0 };
+	struct bootm_headers img = { 0 };
 	efi_status_t ret;
 
 	if (fdt == EFI_FDT_USE_INTERNAL) {
diff --git a/cmd/booti.c b/cmd/booti.c
index 397d4b83236..6ac39193db8 100644
--- a/cmd/booti.c
+++ b/cmd/booti.c
@@ -21,7 +21,7 @@ DECLARE_GLOBAL_DATA_PTR;
  * Image booting support
  */
 static int booti_start(struct cmd_tbl *cmdtp, int flag, int argc,
-		       char *const argv[], bootm_headers_t *images)
+		       char *const argv[], struct bootm_headers *images)
 {
 	int ret;
 	ulong ld;
diff --git a/cmd/bootm.c b/cmd/bootm.c
index 9fe8ce4a27c..d764a27002d 100644
--- a/cmd/bootm.c
+++ b/cmd/bootm.c
@@ -511,7 +511,7 @@ static int do_imls_nand(void)
 			continue;
 
 		for (off = 0; off < mtd->size; off += mtd->erasesize) {
-			const image_header_t *header;
+			const struct legacy_img_hdr *header;
 			int ret;
 
 			if (nand_block_isbad(mtd, off))
@@ -529,7 +529,7 @@ static int do_imls_nand(void)
 			switch (genimg_get_format(buffer)) {
 #if defined(CONFIG_LEGACY_IMAGE_FORMAT)
 			case IMAGE_FORMAT_LEGACY:
-				header = (const image_header_t *)buffer;
+				header = (const struct legacy_img_hdr *)buffer;
 
 				len = image_get_image_size(header);
 				nand_imls_legacyimage(mtd, nand_dev, off, len);
diff --git a/cmd/bootmenu.c b/cmd/bootmenu.c
index 704d36debe0..3340be16325 100644
--- a/cmd/bootmenu.c
+++ b/cmd/bootmenu.c
@@ -7,7 +7,7 @@
 #include <common.h>
 #include <command.h>
 #include <ansi.h>
-#include <efi_loader.h>
+#include <efi_config.h>
 #include <efi_variable.h>
 #include <env.h>
 #include <log.h>
@@ -220,7 +220,7 @@ static int prepare_bootmenu_entry(struct bootmenu_data *menu,
 	return 1;
 }
 
-#if (CONFIG_IS_ENABLED(CMD_BOOTEFI_BOOTMGR))
+#if (CONFIG_IS_ENABLED(CMD_BOOTEFI_BOOTMGR)) && (CONFIG_IS_ENABLED(CMD_EFICONFIG))
 /**
  * prepare_uefi_bootorder_entry() - generate the uefi bootmenu entries
  *
@@ -340,11 +340,21 @@ static struct bootmenu_data *bootmenu_create(int delay)
 	if (ret < 0)
 		goto cleanup;
 
-#if (CONFIG_IS_ENABLED(CMD_BOOTEFI_BOOTMGR))
+#if (CONFIG_IS_ENABLED(CMD_BOOTEFI_BOOTMGR)) && (CONFIG_IS_ENABLED(CMD_EFICONFIG))
 	if (i < MAX_COUNT - 1) {
-			ret = prepare_uefi_bootorder_entry(menu, &iter, &i);
-			if (ret < 0 && ret != -ENOENT)
-				goto cleanup;
+		efi_status_t efi_ret;
+
+		/*
+		 * UEFI specification requires booting from removal media using
+		 * a architecture-specific default image name such as BOOTAA64.EFI.
+		 */
+		efi_ret = eficonfig_generate_media_device_boot_option();
+		if (efi_ret != EFI_SUCCESS && efi_ret != EFI_NOT_FOUND)
+			goto cleanup;
+
+		ret = prepare_uefi_bootorder_entry(menu, &iter, &i);
+		if (ret < 0 && ret != -ENOENT)
+			goto cleanup;
 	}
 #endif
 
diff --git a/cmd/bootz.c b/cmd/bootz.c
index 4f024bde5fe..f1423573d23 100644
--- a/cmd/bootz.c
+++ b/cmd/bootz.c
@@ -25,7 +25,7 @@ int __weak bootz_setup(ulong image, ulong *start, ulong *end)
  * zImage booting support
  */
 static int bootz_start(struct cmd_tbl *cmdtp, int flag, int argc,
-		       char *const argv[], bootm_headers_t *images)
+		       char *const argv[], struct bootm_headers *images)
 {
 	int ret;
 	ulong zi_start, zi_end;
diff --git a/cmd/cyclic.c b/cmd/cyclic.c
new file mode 100644
index 00000000000..c1bc556aade
--- /dev/null
+++ b/cmd/cyclic.c
@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * A general-purpose cyclic execution infrastructure, to allow "small"
+ * (run-time wise) functions to be executed at a specified frequency.
+ * Things like LED blinking or watchdog triggering are examples for such
+ * tasks.
+ *
+ * Copyright (C) 2022 Stefan Roese <sr@denx.de>
+ */
+
+#include <common.h>
+#include <command.h>
+#include <cyclic.h>
+#include <div64.h>
+#include <malloc.h>
+#include <linux/delay.h>
+
+struct cyclic_demo_info {
+	uint delay_us;
+};
+
+static void cyclic_demo(void *ctx)
+{
+	struct cyclic_demo_info *info = ctx;
+
+	/* Just a small dummy delay here */
+	udelay(info->delay_us);
+}
+
+static int do_cyclic_demo(struct cmd_tbl *cmdtp, int flag, int argc,
+			  char *const argv[])
+{
+	struct cyclic_demo_info *info;
+	struct cyclic_info *cyclic;
+	uint time_ms;
+
+	if (argc < 3)
+		return CMD_RET_USAGE;
+
+	info = malloc(sizeof(struct cyclic_demo_info));
+	if (!info) {
+		printf("out of memory\n");
+                return CMD_RET_FAILURE;
+	}
+
+	time_ms = simple_strtoul(argv[1], NULL, 0);
+	info->delay_us = simple_strtoul(argv[2], NULL, 0);
+
+	/* Register demo cyclic function */
+	cyclic = cyclic_register(cyclic_demo, time_ms * 1000, "cyclic_demo",
+				 info);
+	if (!cyclic)
+		printf("Registering of cyclic_demo failed\n");
+
+	printf("Registered function \"%s\" to be executed all %dms\n",
+	       "cyclic_demo", time_ms);
+
+	return 0;
+}
+
+static int do_cyclic_list(struct cmd_tbl *cmdtp, int flag, int argc,
+			  char *const argv[])
+{
+	struct cyclic_info *cyclic, *tmp;
+	u64 cnt, freq;
+
+	list_for_each_entry_safe(cyclic, tmp, cyclic_get_list(), list) {
+		cnt = cyclic->run_cnt * 1000000ULL * 100ULL;
+		freq = lldiv(cnt, timer_get_us() - cyclic->start_time_us);
+		printf("function: %s, cpu-time: %lld us, frequency: %lld.%02d times/s\n",
+		       cyclic->name, cyclic->cpu_time_us,
+		       lldiv(freq, 100), do_div(freq, 100));
+	}
+
+	return 0;
+}
+
+static char cyclic_help_text[] =
+	"cyclic demo <cycletime_ms> <delay_us> - register cyclic demo function\n"
+	"cyclic list - list cyclic functions\n";
+
+U_BOOT_CMD_WITH_SUBCMDS(cyclic, "Cyclic", cyclic_help_text,
+	U_BOOT_SUBCMD_MKENT(demo, 3, 1, do_cyclic_demo),
+	U_BOOT_SUBCMD_MKENT(list, 1, 1, do_cyclic_list));
diff --git a/cmd/disk.c b/cmd/disk.c
index cb3b990ba3a..3d7bc2f6018 100644
--- a/cmd/disk.c
+++ b/cmd/disk.c
@@ -20,7 +20,7 @@ int common_diskboot(struct cmd_tbl *cmdtp, const char *intf, int argc,
 	ulong cnt;
 	struct disk_partition info;
 #if defined(CONFIG_LEGACY_IMAGE_FORMAT)
-	image_header_t *hdr;
+	struct legacy_img_hdr *hdr;
 #endif
 	struct blk_desc *dev_desc;
 
@@ -68,7 +68,7 @@ int common_diskboot(struct cmd_tbl *cmdtp, const char *intf, int argc,
 	switch (genimg_get_format((void *) addr)) {
 #if defined(CONFIG_LEGACY_IMAGE_FORMAT)
 	case IMAGE_FORMAT_LEGACY:
-		hdr = (image_header_t *) addr;
+		hdr = (struct legacy_img_hdr *)addr;
 
 		bootstage_mark(BOOTSTAGE_ID_IDE_FORMAT);
 
diff --git a/cmd/eficonfig.c b/cmd/eficonfig.c
new file mode 100644
index 00000000000..2595dd95631
--- /dev/null
+++ b/cmd/eficonfig.c
@@ -0,0 +1,2502 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ *  Menu-driven UEFI Variable maintenance
+ *
+ *  Copyright (c) 2022 Masahisa Kojima, Linaro Limited
+ */
+
+#include <ansi.h>
+#include <common.h>
+#include <charset.h>
+#include <efi_loader.h>
+#include <efi_load_initrd.h>
+#include <efi_config.h>
+#include <efi_variable.h>
+#include <log.h>
+#include <malloc.h>
+#include <menu.h>
+#include <sort.h>
+#include <watchdog.h>
+#include <asm/unaligned.h>
+#include <linux/delay.h>
+
+static struct efi_simple_text_input_protocol *cin;
+
+#define EFICONFIG_DESCRIPTION_MAX 32
+#define EFICONFIG_OPTIONAL_DATA_MAX 64
+
+/**
+ * struct eficonfig_filepath_info - structure to be used to store file path
+ *
+ * @name:	file or directory name
+ * @list:	list structure
+ */
+struct eficonfig_filepath_info {
+	char *name;
+	struct list_head list;
+};
+
+/**
+ * struct eficonfig_boot_option - structure to be used for updating UEFI boot option
+ *
+ * @file_info:		user selected file info
+ * @initrd_info:	user selected initrd file info
+ * @boot_index:		index of the boot option
+ * @description:	pointer to the description string
+ * @optional_data:	pointer to the optional_data
+ * @edit_completed:	flag indicates edit complete
+ */
+struct eficonfig_boot_option {
+	struct eficonfig_select_file_info file_info;
+	struct eficonfig_select_file_info initrd_info;
+	unsigned int boot_index;
+	u16 *description;
+	u16 *optional_data;
+	bool edit_completed;
+};
+
+/**
+ * struct eficonfig_volume_entry_data - structure to be used to store volume info
+ *
+ * @file_info:	pointer to file info structure
+ * @v:		pointer to the protocol interface
+ * @dp:		pointer to the device path
+ */
+struct eficonfig_volume_entry_data {
+	struct eficonfig_select_file_info *file_info;
+	struct efi_simple_file_system_protocol *v;
+	struct efi_device_path *dp;
+};
+
+/**
+ * struct eficonfig_file_entry_data - structure to be used to store file info
+ *
+ * @file_info:		pointer to file info structure
+ * @is_directory:	flag to identify the directory or file
+ * @file_name:		name of directory or file
+ */
+struct eficonfig_file_entry_data {
+	struct eficonfig_select_file_info *file_info;
+	bool is_directory;
+	char *file_name;
+};
+
+/**
+ * struct eficonfig_boot_selection_data - structure to be used to select the boot option entry
+ *
+ * @boot_index:	index of the boot option
+ * @selected:		pointer to store the selected index in the BootOrder variable
+ */
+struct eficonfig_boot_selection_data {
+	u16 boot_index;
+	int *selected;
+};
+
+/**
+ * struct eficonfig_boot_order - structure to be used to update BootOrder variable
+ *
+ * @num:		index in the menu entry
+ * @description:	pointer to the description string
+ * @boot_index:		boot option index
+ * @active:		flag to include the boot option into BootOrder variable
+ * @list:		list structure
+ */
+struct eficonfig_boot_order {
+	u32 num;
+	u16 *description;
+	u32 boot_index;
+	bool active;
+	struct list_head list;
+};
+
+/**
+ * eficonfig_print_msg() - print message
+ *
+ * display the message to the user, user proceeds the screen
+ * with any key press.
+ *
+ * @items:		pointer to the structure of each menu entry
+ * @count:		the number of menu entry
+ * @menu_header:	pointer to the menu header string
+ * Return:	status code
+ */
+void eficonfig_print_msg(char *msg)
+{
+	/* Flush input */
+	while (tstc())
+		getchar();
+
+	printf(ANSI_CURSOR_HIDE
+	       ANSI_CLEAR_CONSOLE
+	       ANSI_CURSOR_POSITION
+	       "%s\n\n  Press any key to continue", 3, 4, msg);
+
+	getchar();
+}
+
+/**
+ * eficonfig_print_entry() - print each menu entry
+ *
+ * @data:	pointer to the data associated with each menu entry
+ */
+static void eficonfig_print_entry(void *data)
+{
+	struct eficonfig_entry *entry = data;
+	int reverse = (entry->efi_menu->active == entry->num);
+
+	/* TODO: support scroll or page for many entries */
+
+	/*
+	 * Move cursor to line where the entry will be drawn (entry->num)
+	 * First 3 lines(menu header) + 1 empty line
+	 */
+	printf(ANSI_CURSOR_POSITION, entry->num + 4, 7);
+
+	if (reverse)
+		puts(ANSI_COLOR_REVERSE);
+
+	printf("%s", entry->title);
+
+	if (reverse)
+		puts(ANSI_COLOR_RESET);
+}
+
+/**
+ * eficonfig_display_statusline() - print status line
+ *
+ * @m:	pointer to the menu structure
+ */
+static void eficonfig_display_statusline(struct menu *m)
+{
+	struct eficonfig_entry *entry;
+
+	if (menu_default_choice(m, (void *)&entry) < 0)
+		return;
+
+	printf(ANSI_CURSOR_POSITION
+	      "\n%s\n"
+	       ANSI_CURSOR_POSITION ANSI_CLEAR_LINE ANSI_CURSOR_POSITION
+	       "  Press UP/DOWN to move, ENTER to select, ESC/CTRL+C to quit"
+	       ANSI_CLEAR_LINE_TO_END ANSI_CURSOR_POSITION ANSI_CLEAR_LINE,
+	       1, 1, entry->efi_menu->menu_header, entry->efi_menu->count + 5, 1,
+	       entry->efi_menu->count + 6, 1, entry->efi_menu->count + 7, 1);
+}
+
+/**
+ * eficonfig_choice_entry() - user key input handler
+ *
+ * @data:	pointer to the efimenu structure
+ * Return:	key string to identify the selected entry
+ */
+static char *eficonfig_choice_entry(void *data)
+{
+	int esc = 0;
+	struct list_head *pos, *n;
+	struct eficonfig_entry *entry;
+	enum bootmenu_key key = KEY_NONE;
+	struct efimenu *efi_menu = data;
+
+	while (1) {
+		bootmenu_loop((struct bootmenu_data *)efi_menu, &key, &esc);
+
+		switch (key) {
+		case KEY_UP:
+			if (efi_menu->active > 0)
+				--efi_menu->active;
+			/* no menu key selected, regenerate menu */
+			return NULL;
+		case KEY_DOWN:
+			if (efi_menu->active < efi_menu->count - 1)
+				++efi_menu->active;
+			/* no menu key selected, regenerate menu */
+			return NULL;
+		case KEY_SELECT:
+			list_for_each_safe(pos, n, &efi_menu->list) {
+				entry = list_entry(pos, struct eficonfig_entry, list);
+				if (entry->num == efi_menu->active)
+					return entry->key;
+			}
+			break;
+		case KEY_QUIT:
+			/* Quit by choosing the last entry */
+			entry = list_last_entry(&efi_menu->list, struct eficonfig_entry, list);
+			return entry->key;
+		default:
+			/* Pressed key is not valid, no need to regenerate the menu */
+			break;
+		}
+	}
+}
+
+/**
+ * eficonfig_destroy() - destroy efimenu
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ */
+void eficonfig_destroy(struct efimenu *efi_menu)
+{
+	struct list_head *pos, *n;
+	struct eficonfig_entry *entry;
+
+	if (!efi_menu)
+		return;
+
+	list_for_each_safe(pos, n, &efi_menu->list) {
+		entry = list_entry(pos, struct eficonfig_entry, list);
+		free(entry->title);
+		list_del(&entry->list);
+		free(entry);
+	}
+	free(efi_menu->menu_header);
+	free(efi_menu);
+}
+
+/**
+ * eficonfig_process_quit() - callback function for "Quit" entry
+ *
+ * @data:	pointer to the data
+ * Return:	status code
+ */
+efi_status_t eficonfig_process_quit(void *data)
+{
+	return EFI_ABORTED;
+}
+
+/**
+ * append_entry() - append menu item
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ * @title:	pointer to the entry title
+ * @func:	callback of each entry
+ * @data:	pointer to the data to be passed to each entry callback
+ * Return:	status code
+ */
+static efi_status_t append_entry(struct efimenu *efi_menu,
+				 char *title, eficonfig_entry_func func, void *data)
+{
+	struct eficonfig_entry *entry;
+
+	if (efi_menu->count >= EFICONFIG_ENTRY_NUM_MAX)
+		return EFI_OUT_OF_RESOURCES;
+
+	entry = calloc(1, sizeof(struct eficonfig_entry));
+	if (!entry)
+		return EFI_OUT_OF_RESOURCES;
+
+	entry->title = title;
+	sprintf(entry->key, "%d", efi_menu->count);
+	entry->efi_menu = efi_menu;
+	entry->func = func;
+	entry->data = data;
+	entry->num = efi_menu->count++;
+	list_add_tail(&entry->list, &efi_menu->list);
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * append_quit_entry() - append quit entry
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ * Return:	status code
+ */
+static efi_status_t append_quit_entry(struct efimenu *efi_menu)
+{
+	char *title;
+	efi_status_t ret;
+
+	title = strdup("Quit");
+	if (!title)
+		return EFI_OUT_OF_RESOURCES;
+
+	ret = append_entry(efi_menu, title, eficonfig_process_quit, NULL);
+	if (ret != EFI_SUCCESS)
+		free(title);
+
+	return ret;
+}
+
+/**
+ * eficonfig_create_fixed_menu() - create fixed entry menu structure
+ *
+ * @items:	pointer to the menu entry item
+ * @count:	the number of menu entry
+ * Return:	pointer to the efimenu structure
+ */
+void *eficonfig_create_fixed_menu(const struct eficonfig_item *items, int count)
+{
+	u32 i;
+	char *title;
+	efi_status_t ret;
+	struct efimenu *efi_menu;
+	const struct eficonfig_item *iter = items;
+
+	efi_menu = calloc(1, sizeof(struct efimenu));
+	if (!efi_menu)
+		return NULL;
+
+	INIT_LIST_HEAD(&efi_menu->list);
+	for (i = 0; i < count; i++, iter++) {
+		title = strdup(iter->title);
+		if (!title)
+			goto out;
+
+		ret = append_entry(efi_menu, title, iter->func, iter->data);
+		if (ret != EFI_SUCCESS) {
+			free(title);
+			goto out;
+		}
+	}
+
+	return efi_menu;
+out:
+	eficonfig_destroy(efi_menu);
+
+	return NULL;
+}
+
+/**
+ * eficonfig_process_common() - main handler for UEFI menu
+ *
+ * Construct the structures required to show the menu, then handle
+ * the user input interacting with u-boot menu functions.
+ *
+ * @efi_menu:		pointer to the efimenu structure
+ * @menu_header:	pointer to the menu header string
+ * Return:		status code
+ */
+efi_status_t eficonfig_process_common(struct efimenu *efi_menu, char *menu_header)
+{
+	struct menu *menu;
+	void *choice = NULL;
+	struct list_head *pos, *n;
+	struct eficonfig_entry *entry;
+	efi_status_t ret = EFI_SUCCESS;
+
+	if (efi_menu->count > EFICONFIG_ENTRY_NUM_MAX)
+		return EFI_OUT_OF_RESOURCES;
+
+	efi_menu->delay = -1;
+	efi_menu->active = 0;
+
+	if (menu_header) {
+		efi_menu->menu_header = strdup(menu_header);
+		if (!efi_menu->menu_header)
+			return EFI_OUT_OF_RESOURCES;
+	}
+
+	menu = menu_create(NULL, 0, 1, eficonfig_display_statusline,
+			   eficonfig_print_entry, eficonfig_choice_entry,
+			   efi_menu);
+	if (!menu)
+		return EFI_INVALID_PARAMETER;
+
+	list_for_each_safe(pos, n, &efi_menu->list) {
+		entry = list_entry(pos, struct eficonfig_entry, list);
+		if (!menu_item_add(menu, entry->key, entry)) {
+			ret = EFI_INVALID_PARAMETER;
+			goto out;
+		}
+	}
+
+	entry = list_first_entry_or_null(&efi_menu->list, struct eficonfig_entry, list);
+	if (entry)
+		menu_default_set(menu, entry->key);
+
+	printf(ANSI_CURSOR_HIDE
+	       ANSI_CLEAR_CONSOLE
+	       ANSI_CURSOR_POSITION, 1, 1);
+
+	if (menu_get_choice(menu, &choice)) {
+		entry = choice;
+		if (entry->func)
+			ret = entry->func(entry->data);
+	}
+out:
+	menu_destroy(menu);
+
+	printf(ANSI_CLEAR_CONSOLE
+	       ANSI_CURSOR_POSITION
+	       ANSI_CURSOR_SHOW, 1, 1);
+
+	return ret;
+}
+
+/**
+ * eficonfig_volume_selected() - handler of volume selection
+ *
+ * @data:	pointer to the data of selected entry
+ * Return:	status code
+ */
+static efi_status_t eficonfig_volume_selected(void *data)
+{
+	struct eficonfig_volume_entry_data *info = data;
+
+	if (info) {
+		info->file_info->current_volume = info->v;
+		info->file_info->dp_volume = info->dp;
+	}
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * create_selected_device_path() - create device path
+ *
+ * @file_info:	pointer to the selected file information
+ * Return:
+ * device path or NULL. Caller must free the returned value
+ */
+static
+struct efi_device_path *create_selected_device_path(struct eficonfig_select_file_info *file_info)
+{
+	char *p;
+	void *buf;
+	efi_uintn_t fp_size;
+	struct efi_device_path *dp;
+	struct efi_device_path_file_path *fp;
+
+	fp_size = sizeof(struct efi_device_path) +
+		  ((u16_strlen(file_info->current_path) + 1) * sizeof(u16));
+	buf = calloc(1, fp_size + sizeof(END));
+	if (!buf)
+		return NULL;
+
+	fp = buf;
+	fp->dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE,
+	fp->dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH,
+	fp->dp.length = (u16)fp_size;
+	u16_strcpy(fp->str, file_info->current_path);
+
+	p = buf;
+	p += fp_size;
+	*((struct efi_device_path *)p) = END;
+
+	dp = efi_dp_append(file_info->dp_volume, (struct efi_device_path *)buf);
+	free(buf);
+
+	return dp;
+}
+
+/**
+ * eficonfig_file_selected() - handler of file selection
+ *
+ * @data:	pointer to the data of selected entry
+ * Return:	status code
+ */
+static efi_status_t eficonfig_file_selected(void *data)
+{
+	u16 *tmp;
+	struct eficonfig_file_entry_data *info = data;
+
+	if (!info)
+		return EFI_INVALID_PARAMETER;
+
+	if (!strcmp(info->file_name, "..")) {
+		struct eficonfig_filepath_info *iter;
+		struct list_head *pos, *n;
+		int is_last;
+		char *filepath;
+		tmp = info->file_info->current_path;
+
+		memset(info->file_info->current_path, 0, EFICONFIG_FILE_PATH_BUF_SIZE);
+		filepath = calloc(1, EFICONFIG_FILE_PATH_MAX);
+		if (!filepath)
+			return EFI_OUT_OF_RESOURCES;
+
+		list_for_each_safe(pos, n, &info->file_info->filepath_list) {
+			iter = list_entry(pos, struct eficonfig_filepath_info, list);
+
+			is_last = list_is_last(&iter->list, &info->file_info->filepath_list);
+			if (is_last) {
+				list_del(&iter->list);
+				free(iter->name);
+				free(iter);
+				break;
+			}
+			strlcat(filepath, iter->name, EFICONFIG_FILE_PATH_MAX);
+		}
+		utf8_utf16_strcpy(&tmp, filepath);
+	} else {
+		size_t new_len;
+		struct eficonfig_filepath_info *filepath_info;
+
+		new_len = u16_strlen(info->file_info->current_path) +
+				     strlen(info->file_name);
+		if (new_len >= EFICONFIG_FILE_PATH_MAX) {
+			eficonfig_print_msg("File path is too long!");
+			return EFI_INVALID_PARAMETER;
+		}
+		tmp = &info->file_info->current_path[u16_strlen(info->file_info->current_path)];
+		utf8_utf16_strcpy(&tmp, info->file_name);
+
+		filepath_info = calloc(1, sizeof(struct eficonfig_filepath_info));
+		if (!filepath_info)
+			return EFI_OUT_OF_RESOURCES;
+
+		filepath_info->name = strdup(info->file_name);
+		if (!filepath_info->name) {
+			free(filepath_info);
+			return EFI_OUT_OF_RESOURCES;
+		}
+		list_add_tail(&filepath_info->list, &info->file_info->filepath_list);
+
+		if (!info->is_directory)
+			info->file_info->file_selected = true;
+	}
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * eficonfig_select_volume() - construct the volume selection menu
+ *
+ * @file_info:	pointer to the file selection structure
+ * Return:	status code
+ */
+static efi_status_t eficonfig_select_volume(struct eficonfig_select_file_info *file_info)
+{
+	u32 i;
+	efi_status_t ret;
+	efi_uintn_t count;
+	struct efimenu *efi_menu;
+	struct list_head *pos, *n;
+	struct efi_handler *handler;
+	struct eficonfig_entry *entry;
+	struct efi_device_path *device_path;
+	efi_handle_t *volume_handles = NULL;
+	struct efi_simple_file_system_protocol *v;
+
+	ret = efi_locate_handle_buffer_int(BY_PROTOCOL, &efi_simple_file_system_protocol_guid,
+					   NULL, &count, (efi_handle_t **)&volume_handles);
+	if (ret != EFI_SUCCESS) {
+		eficonfig_print_msg("No block device found!");
+		return ret;
+	}
+
+	efi_menu = calloc(1, sizeof(struct efimenu));
+	if (!efi_menu)
+		return EFI_OUT_OF_RESOURCES;
+
+	INIT_LIST_HEAD(&efi_menu->list);
+	for (i = 0; i < count; i++) {
+		char *devname;
+		struct efi_block_io *block_io;
+		struct eficonfig_volume_entry_data *info;
+
+		if (efi_menu->count >= EFICONFIG_ENTRY_NUM_MAX - 1)
+			break;
+
+		ret = efi_search_protocol(volume_handles[i],
+					  &efi_simple_file_system_protocol_guid, &handler);
+		if (ret != EFI_SUCCESS)
+			continue;
+		ret = efi_protocol_open(handler, (void **)&v, efi_root, NULL,
+					EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+		if (ret != EFI_SUCCESS)
+			continue;
+
+		ret = efi_search_protocol(volume_handles[i], &efi_guid_device_path, &handler);
+		if (ret != EFI_SUCCESS)
+			continue;
+		ret = efi_protocol_open(handler, (void **)&device_path,
+					efi_root, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+		if (ret != EFI_SUCCESS)
+			continue;
+
+		ret = efi_search_protocol(volume_handles[i], &efi_block_io_guid, &handler);
+		if (ret != EFI_SUCCESS)
+			continue;
+		ret = efi_protocol_open(handler, (void **)&block_io,
+					efi_root, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+		if (ret != EFI_SUCCESS)
+			continue;
+
+		info = calloc(1, sizeof(struct eficonfig_volume_entry_data));
+		if (!info) {
+			ret = EFI_OUT_OF_RESOURCES;
+			goto out;
+		}
+
+		devname = calloc(1, BOOTMENU_DEVICE_NAME_MAX);
+		if (!devname) {
+			free(info);
+			ret = EFI_OUT_OF_RESOURCES;
+			goto out;
+		}
+		ret = efi_disk_get_device_name(volume_handles[i], devname,
+					       BOOTMENU_DEVICE_NAME_MAX);
+		if (ret != EFI_SUCCESS) {
+			free(info);
+			goto out;
+		}
+
+		info->v = v;
+		info->dp = device_path;
+		info->file_info = file_info;
+		ret = append_entry(efi_menu, devname, eficonfig_volume_selected, info);
+		if (ret != EFI_SUCCESS) {
+			free(info);
+			goto out;
+		}
+	}
+
+	ret = append_quit_entry(efi_menu);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = eficonfig_process_common(efi_menu, "  ** Select Volume **");
+out:
+	efi_free_pool(volume_handles);
+	list_for_each_safe(pos, n, &efi_menu->list) {
+		entry = list_entry(pos, struct eficonfig_entry, list);
+		free(entry->data);
+	}
+	eficonfig_destroy(efi_menu);
+
+	return ret;
+}
+
+/**
+ * sort_file() - sort the file name in ascii order
+ *
+ * @data1:	pointer to the file entry data
+ * @data2:	pointer to the file entry data
+ * Return:	-1 if the data1 file name is less than data2 file name,
+ *		0 if both file name match,
+ *		1 if the data1 file name is greater thant data2 file name.
+ */
+static int sort_file(const void *arg1, const void *arg2)
+{
+	const struct eficonfig_file_entry_data *data1, *data2;
+
+	data1 = *((const struct eficonfig_file_entry_data **)arg1);
+	data2 = *((const struct eficonfig_file_entry_data **)arg2);
+
+	return strcasecmp(data1->file_name, data2->file_name);
+}
+
+/**
+ * eficonfig_create_file_entry() - construct the file menu entry
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ * @count:	number of the directory and file
+ * @tmp_infos:	pointer to the entry data array
+ * @f:		pointer to the file handle
+ * @buf:	pointer to the buffer to store the directory information
+ * @file_info:	pointer to the file selection structure
+ * Return:	status code
+ */
+static efi_status_t
+eficonfig_create_file_entry(struct efimenu *efi_menu, u32 count,
+			    struct eficonfig_file_entry_data **tmp_infos,
+			    struct efi_file_handle *f, struct efi_file_info *buf,
+			    struct eficonfig_select_file_info *file_info)
+{
+	char *name, *p;
+	efi_uintn_t len;
+	efi_status_t ret;
+	u32 i, entry_num = 0;
+	struct eficonfig_file_entry_data *info;
+
+	efi_file_setpos_int(f, 0);
+	/* Read directory and construct menu structure */
+	for (i = 0; i < count; i++) {
+		if (entry_num >= EFICONFIG_ENTRY_NUM_MAX - 1)
+			break;
+
+		len = sizeof(struct efi_file_info) + EFICONFIG_FILE_PATH_BUF_SIZE;
+		ret = efi_file_read_int(f, &len, buf);
+		if (ret != EFI_SUCCESS || len == 0)
+			break;
+
+		info = calloc(1, sizeof(struct eficonfig_file_entry_data));
+		if (!info) {
+			ret = EFI_OUT_OF_RESOURCES;
+			goto out;
+		}
+
+		/* append '\\' at the end of directory name */
+		name = calloc(1, utf16_utf8_strlen(buf->file_name) + 2);
+		if (!name) {
+			ret = EFI_OUT_OF_RESOURCES;
+			free(info);
+			goto out;
+		}
+		p = name;
+		utf16_utf8_strcpy(&p, buf->file_name);
+		if (buf->attribute & EFI_FILE_DIRECTORY) {
+			/* filter out u'.' */
+			if (!u16_strcmp(buf->file_name, u".")) {
+				free(info);
+				free(name);
+				continue;
+			}
+			name[u16_strlen(buf->file_name)] = '\\';
+			info->is_directory = true;
+		}
+
+		info->file_name = name;
+		info->file_info = file_info;
+		tmp_infos[entry_num++] = info;
+	}
+
+	qsort(tmp_infos, entry_num, sizeof(*tmp_infos),
+	      (int (*)(const void *, const void *))sort_file);
+
+	for (i = 0; i < entry_num; i++) {
+		ret = append_entry(efi_menu, tmp_infos[i]->file_name,
+				   eficonfig_file_selected, tmp_infos[i]);
+		if (ret != EFI_SUCCESS)
+			goto out;
+	}
+
+out:
+	return ret;
+}
+
+/**
+ * eficonfig_select_file() - construct the file selection menu
+ *
+ * @file_info:	pointer to the file selection structure
+ * @root:	pointer to the file handle
+ * Return:	status code
+ */
+static efi_status_t eficonfig_select_file(struct eficonfig_select_file_info *file_info,
+					  struct efi_file_handle *root)
+{
+	u32 count = 0, i;
+	efi_uintn_t len;
+	efi_status_t ret;
+	struct efimenu *efi_menu;
+	struct efi_file_handle *f;
+	struct efi_file_info *buf;
+	struct eficonfig_file_entry_data **tmp_infos;
+
+	buf = calloc(1, sizeof(struct efi_file_info) + EFICONFIG_FILE_PATH_BUF_SIZE);
+	if (!buf)
+		return EFI_OUT_OF_RESOURCES;
+
+	while (!file_info->file_selected) {
+		efi_menu = calloc(1, sizeof(struct efimenu));
+		if (!efi_menu) {
+			ret = EFI_OUT_OF_RESOURCES;
+			goto out;
+		}
+		INIT_LIST_HEAD(&efi_menu->list);
+
+		ret = efi_file_open_int(root, &f, file_info->current_path, EFI_FILE_MODE_READ, 0);
+		if (ret != EFI_SUCCESS) {
+			eficonfig_print_msg("Reading volume failed!");
+			free(efi_menu);
+			ret = EFI_ABORTED;
+			goto out;
+		}
+
+		/* Count the number of directory entries */
+		for (;;) {
+			len = sizeof(struct efi_file_info) + EFICONFIG_FILE_PATH_BUF_SIZE;
+			ret = efi_file_read_int(f, &len, buf);
+			if (ret != EFI_SUCCESS || len == 0)
+				break;
+
+			count++;
+		}
+
+		/* allocate array to sort the entry */
+		tmp_infos = calloc(count, sizeof(*tmp_infos));
+		if (!tmp_infos) {
+			ret = EFI_OUT_OF_RESOURCES;
+			goto err;
+		}
+
+		ret = eficonfig_create_file_entry(efi_menu, count, tmp_infos,
+						  f, buf, file_info);
+		if (ret != EFI_SUCCESS)
+			goto err;
+
+		ret = append_quit_entry(efi_menu);
+		if (ret != EFI_SUCCESS)
+			goto err;
+
+		ret = eficonfig_process_common(efi_menu, "  ** Select File **");
+err:
+		efi_file_close_int(f);
+		eficonfig_destroy(efi_menu);
+
+		if (tmp_infos) {
+			for (i = 0; i < count; i++)
+				free(tmp_infos[i]);
+		}
+
+		free(tmp_infos);
+
+		if (ret != EFI_SUCCESS)
+			break;
+	}
+
+out:
+	free(buf);
+
+	return ret;
+}
+
+/**
+ * handle_user_input() - handle user input
+ *
+ * @buf:	pointer to the buffer
+ * @buf_size:	size of the buffer
+ * @cursor_col:	cursor column for user input
+ * @msg:	pointer to the string to display
+ * Return:	status code
+ */
+static efi_status_t handle_user_input(u16 *buf, int buf_size,
+				      int cursor_col, char *msg)
+{
+	u16 *tmp;
+	efi_status_t ret;
+
+	printf(ANSI_CLEAR_CONSOLE
+	       ANSI_CURSOR_POSITION
+	       "%s"
+	       ANSI_CURSOR_POSITION
+	       "  Press ENTER to complete, ESC/CTRL+C to quit",
+	       0, 1, msg, 8, 1);
+
+	/* tmp is used to accept user cancel */
+	tmp = calloc(1, buf_size * sizeof(u16));
+	if (!tmp)
+		return EFI_OUT_OF_RESOURCES;
+
+	ret = efi_console_get_u16_string(cin, tmp, buf_size, NULL, 4, cursor_col);
+	if (ret == EFI_SUCCESS)
+		u16_strcpy(buf, tmp);
+
+	free(tmp);
+
+	/* to stay the parent menu */
+	ret = (ret == EFI_ABORTED) ? EFI_NOT_READY : ret;
+
+	return ret;
+}
+
+/**
+ * eficonfig_boot_add_enter_description() - handle user input for description
+ *
+ * @data:	pointer to the internal boot option structure
+ * Return:	status code
+ */
+static efi_status_t eficonfig_boot_add_enter_description(void *data)
+{
+	struct eficonfig_boot_option *bo = data;
+
+	return handle_user_input(bo->description, EFICONFIG_DESCRIPTION_MAX, 22,
+				 "\n  ** Edit Description **\n"
+				 "\n"
+				 "  enter description: ");
+}
+
+/**
+ * eficonfig_boot_add_optional_data() - handle user input for optional data
+ *
+ * @data:	pointer to the internal boot option structure
+ * Return:	status code
+ */
+static efi_status_t eficonfig_boot_add_optional_data(void *data)
+{
+	struct eficonfig_boot_option *bo = data;
+
+	return handle_user_input(bo->optional_data, EFICONFIG_OPTIONAL_DATA_MAX, 24,
+				 "\n  ** Edit Optional Data **\n"
+				 "\n"
+				 "  enter optional data:");
+}
+
+/**
+ * eficonfig_boot_edit_save() - handler to save the boot option
+ *
+ * @data:	pointer to the internal boot option structure
+ * Return:	status code
+ */
+static efi_status_t eficonfig_boot_edit_save(void *data)
+{
+	struct eficonfig_boot_option *bo = data;
+
+	if (u16_strlen(bo->description) == 0) {
+		eficonfig_print_msg("Boot Description is empty!");
+		bo->edit_completed = false;
+		return EFI_NOT_READY;
+	}
+	if (u16_strlen(bo->file_info.current_path) == 0) {
+		eficonfig_print_msg("File is not selected!");
+		bo->edit_completed = false;
+		return EFI_NOT_READY;
+	}
+
+	bo->edit_completed = true;
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * eficonfig_process_select_file() - callback function for "Select File" entry
+ *
+ * @data:	pointer to the data
+ * Return:	status code
+ */
+efi_status_t eficonfig_process_select_file(void *data)
+{
+	return EFI_SUCCESS;
+}
+
+/**
+ * eficonfig_process_clear_file_selection() - callback function for "Clear" entry
+ *
+ * @data:	pointer to the data
+ * Return:	status code
+ */
+efi_status_t eficonfig_process_clear_file_selection(void *data)
+{
+	struct eficonfig_select_file_info *file_info = data;
+
+	/* clear the existing file information */
+	file_info->current_volume = NULL;
+	file_info->current_path[0] = u'\0';
+	file_info->dp_volume = NULL;
+
+	return EFI_ABORTED;
+}
+
+static struct eficonfig_item select_file_menu_items[] = {
+	{"Select File", eficonfig_process_select_file},
+	{"Clear", eficonfig_process_clear_file_selection},
+	{"Quit", eficonfig_process_quit},
+};
+
+
+/**
+ * eficonfig_display_select_file_option() - display select file option
+ *
+ * @file_info:	pointer to the file information structure
+ * Return:	status code
+ */
+efi_status_t eficonfig_display_select_file_option(struct eficonfig_select_file_info *file_info)
+{
+	efi_status_t ret;
+	struct efimenu *efi_menu;
+
+	select_file_menu_items[1].data = file_info;
+	efi_menu = eficonfig_create_fixed_menu(select_file_menu_items,
+					       ARRAY_SIZE(select_file_menu_items));
+	if (!efi_menu)
+		return EFI_OUT_OF_RESOURCES;
+
+	ret = eficonfig_process_common(efi_menu, "  ** Update File **");
+	if (ret != EFI_SUCCESS) /* User selects "Clear" or "Quit" */
+		ret = EFI_NOT_READY;
+
+	eficonfig_destroy(efi_menu);
+
+	return ret;
+}
+
+/**
+ * eficonfig_select_file_handler() - handle user file selection
+ *
+ * @data:	pointer to the data
+ * Return:	status code
+ */
+efi_status_t eficonfig_select_file_handler(void *data)
+{
+	size_t len;
+	efi_status_t ret;
+	struct list_head *pos, *n;
+	struct efi_file_handle *root;
+	struct eficonfig_filepath_info *item;
+	struct eficonfig_select_file_info *tmp = NULL;
+	struct eficonfig_select_file_info *file_info = data;
+
+	ret = eficonfig_display_select_file_option(file_info);
+	if (ret != EFI_SUCCESS)
+		return ret;
+
+	tmp = calloc(1, sizeof(struct eficonfig_select_file_info));
+	if (!tmp)
+		return EFI_OUT_OF_RESOURCES;
+
+	tmp->current_path = calloc(1, EFICONFIG_FILE_PATH_BUF_SIZE);
+	if (!tmp->current_path) {
+		free(tmp);
+		return EFI_OUT_OF_RESOURCES;
+	}
+	INIT_LIST_HEAD(&tmp->filepath_list);
+
+	while (!tmp->file_selected) {
+		tmp->current_volume = NULL;
+		memset(tmp->current_path, 0, EFICONFIG_FILE_PATH_BUF_SIZE);
+
+		ret = eficonfig_select_volume(tmp);
+		if (ret != EFI_SUCCESS)
+			goto out;
+
+		if (!tmp->current_volume)
+			return EFI_INVALID_PARAMETER;
+
+		ret = efi_open_volume_int(tmp->current_volume, &root);
+		if (ret != EFI_SUCCESS)
+			goto out;
+
+		ret = eficonfig_select_file(tmp, root);
+		if (ret == EFI_ABORTED)
+			continue;
+		if (ret != EFI_SUCCESS)
+			goto out;
+	}
+
+out:
+	if (ret == EFI_SUCCESS) {
+		len = u16_strlen(tmp->current_path);
+		len = (len >= EFICONFIG_FILE_PATH_MAX) ? (EFICONFIG_FILE_PATH_MAX - 1) : len;
+		memcpy(file_info->current_path, tmp->current_path, len * sizeof(u16));
+		file_info->current_path[len] = u'\0';
+		file_info->current_volume = tmp->current_volume;
+		file_info->dp_volume = tmp->dp_volume;
+	}
+
+	list_for_each_safe(pos, n, &tmp->filepath_list) {
+		item = list_entry(pos, struct eficonfig_filepath_info, list);
+		list_del(&item->list);
+		free(item->name);
+		free(item);
+	}
+	free(tmp->current_path);
+	free(tmp);
+
+	/* to stay the parent menu */
+	ret = (ret == EFI_ABORTED) ? EFI_NOT_READY : ret;
+
+	return ret;
+}
+
+/**
+ * eficonfig_get_unused_bootoption() - get unused "Boot####" index
+ *
+ * @buf:	pointer to the buffer to store boot option variable name
+ * @buf_size:	buffer size
+ * @index:	pointer to store the index in the BootOrder variable
+ * Return:	status code
+ */
+efi_status_t eficonfig_get_unused_bootoption(u16 *buf, efi_uintn_t buf_size,
+					     unsigned int *index)
+{
+	u32 i;
+	efi_status_t ret;
+	efi_uintn_t size;
+
+	if (buf_size < u16_strsize(u"Boot####"))
+		return EFI_BUFFER_TOO_SMALL;
+
+	for (i = 0; i <= 0xFFFF; i++) {
+		size = 0;
+		efi_create_indexed_name(buf, buf_size, "Boot", i);
+		ret = efi_get_variable_int(buf, &efi_global_variable_guid,
+					   NULL, &size, NULL, NULL);
+		if (ret == EFI_BUFFER_TOO_SMALL)
+			continue;
+		else
+			break;
+	}
+
+	if (i > 0xFFFF)
+		return EFI_OUT_OF_RESOURCES;
+
+	*index = i;
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * eficonfig_set_boot_option() - set boot option
+ *
+ * @varname:		pointer to variable name
+ * @dp:			pointer to device path
+ * @label:		pointer to label string
+ * @optional_data:	pointer to optional data
+ * Return:		status code
+ */
+static efi_status_t eficonfig_set_boot_option(u16 *varname, struct efi_device_path *dp,
+					      efi_uintn_t dp_size, u16 *label, char *optional_data)
+{
+	void *p = NULL;
+	efi_status_t ret;
+	efi_uintn_t size;
+	struct efi_load_option lo;
+
+	lo.file_path = dp;
+	lo.file_path_length = dp_size;
+	lo.attributes = LOAD_OPTION_ACTIVE;
+	lo.optional_data = optional_data;
+	lo.label = label;
+
+	size = efi_serialize_load_option(&lo, (u8 **)&p);
+	if (!size)
+		return EFI_INVALID_PARAMETER;
+
+	ret = efi_set_variable_int(varname, &efi_global_variable_guid,
+				   EFI_VARIABLE_NON_VOLATILE |
+				   EFI_VARIABLE_BOOTSERVICE_ACCESS |
+				   EFI_VARIABLE_RUNTIME_ACCESS,
+				   size, p, false);
+	free(p);
+
+	return ret;
+}
+
+/**
+ * eficonfig_append_bootorder() - append new boot option in BootOrder variable
+ *
+ * @index:	"Boot####" index to append to BootOrder variable
+ * Return:	status code
+ */
+efi_status_t eficonfig_append_bootorder(u16 index)
+{
+	u16 *bootorder;
+	efi_status_t ret;
+	u16 *new_bootorder = NULL;
+	efi_uintn_t last, size, new_size;
+
+	/* append new boot option */
+	bootorder = efi_get_var(u"BootOrder", &efi_global_variable_guid, &size);
+	last = size / sizeof(u16);
+	new_size = size + sizeof(u16);
+	new_bootorder = calloc(1, new_size);
+	if (!new_bootorder) {
+		ret = EFI_OUT_OF_RESOURCES;
+		goto out;
+	}
+	memcpy(new_bootorder, bootorder, size);
+	new_bootorder[last] = index;
+
+	ret = efi_set_variable_int(u"BootOrder", &efi_global_variable_guid,
+				   EFI_VARIABLE_NON_VOLATILE |
+				   EFI_VARIABLE_BOOTSERVICE_ACCESS |
+				   EFI_VARIABLE_RUNTIME_ACCESS,
+				   new_size, new_bootorder, false);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+out:
+	free(bootorder);
+	free(new_bootorder);
+
+	return ret;
+}
+
+/**
+ * create_boot_option_entry() - create boot option entry
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ * @title:	pointer to the entry title
+ * @val:	pointer to boot option label
+ * @func:	callback of each entry
+ * @data:	pointer to the data to be passed to each entry callback
+ * Return:	status code
+ */
+static efi_status_t create_boot_option_entry(struct efimenu *efi_menu, char *title, u16 *val,
+					     eficonfig_entry_func func, void *data)
+{
+	u32 len;
+	char *p, *buf;
+
+	len = strlen(title) + 1;
+	if (val)
+		len += utf16_utf8_strlen(val);
+	buf = calloc(1, len);
+	if (!buf)
+		return EFI_OUT_OF_RESOURCES;
+
+	strcpy(buf, title);
+	if (val) {
+		p = buf + strlen(title);
+		utf16_utf8_strcpy(&p, val);
+	}
+
+	return append_entry(efi_menu, buf, func, data);
+}
+
+/**
+ * prepare_file_selection_entry() - prepare file selection entry
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ * @title:	pointer to the title string
+ * @file_info:	pointer to the file info
+ * Return:	status code
+ */
+static efi_status_t prepare_file_selection_entry(struct efimenu *efi_menu, char *title,
+						 struct eficonfig_select_file_info *file_info)
+{
+	u32 len;
+	efi_status_t ret;
+	u16 *file_name = NULL, *p;
+	efi_handle_t handle;
+	char *devname;
+
+	devname = calloc(1, EFICONFIG_VOLUME_PATH_MAX + 1);
+	if (!devname)
+		return EFI_OUT_OF_RESOURCES;
+
+	/* get the device name only when the user already selected the file path */
+	handle = efi_dp_find_obj(file_info->dp_volume, NULL, NULL);
+	if (handle) {
+		ret = efi_disk_get_device_name(handle, devname, EFICONFIG_VOLUME_PATH_MAX);
+		if (ret != EFI_SUCCESS)
+			goto out;
+	}
+
+	/*
+	 * If the preconfigured volume does not exist in the system, display the text
+	 * converted volume device path instead of U-Boot friendly name(e.g. "usb 0:1").
+	 */
+	if (!handle && file_info->dp_volume) {
+		u16 *dp_str;
+		char *q = devname;
+
+		dp_str = efi_dp_str(file_info->dp_volume);
+		if (dp_str)
+			utf16_utf8_strncpy(&q, dp_str, EFICONFIG_VOLUME_PATH_MAX);
+
+		efi_free_pool(dp_str);
+	}
+
+	/* append u'/' to devname, it is just for display purpose. */
+	if (file_info->current_path[0] != u'\0' && file_info->current_path[0] != u'/')
+		strlcat(devname, "/", EFICONFIG_VOLUME_PATH_MAX + 1);
+
+	len = strlen(devname);
+	len += utf16_utf8_strlen(file_info->current_path) + 1;
+	file_name = calloc(1, len * sizeof(u16));
+	if (!file_name) {
+		ret = EFI_OUT_OF_RESOURCES;
+		goto out;
+	}
+
+	p = file_name;
+	utf8_utf16_strcpy(&p, devname);
+	u16_strlcat(file_name, file_info->current_path, len);
+	ret = create_boot_option_entry(efi_menu, title, file_name,
+				       eficonfig_select_file_handler, file_info);
+out:
+	free(devname);
+	free(file_name);
+
+	return ret;
+}
+
+/**
+ * eficonfig_show_boot_option() - prepare menu entry for editing boot option
+ *
+ * Construct the structures to create edit boot option menu
+ *
+ * @bo:		pointer to the boot option
+ * @header_str:	pointer to the header string
+ * Return:	status code
+ */
+static efi_status_t eficonfig_show_boot_option(struct eficonfig_boot_option *bo,
+					       char *header_str)
+{
+	efi_status_t ret;
+	struct efimenu *efi_menu;
+
+	efi_menu = calloc(1, sizeof(struct efimenu));
+	if (!efi_menu)
+		return EFI_OUT_OF_RESOURCES;
+
+	INIT_LIST_HEAD(&efi_menu->list);
+
+	ret = create_boot_option_entry(efi_menu, "Description: ", bo->description,
+				       eficonfig_boot_add_enter_description, bo);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = prepare_file_selection_entry(efi_menu, "File: ", &bo->file_info);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = prepare_file_selection_entry(efi_menu, "Initrd File: ", &bo->initrd_info);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = create_boot_option_entry(efi_menu, "Optional Data: ", bo->optional_data,
+				       eficonfig_boot_add_optional_data, bo);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = create_boot_option_entry(efi_menu, "Save", NULL,
+				       eficonfig_boot_edit_save, bo);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = create_boot_option_entry(efi_menu, "Quit", NULL,
+				       eficonfig_process_quit, NULL);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = eficonfig_process_common(efi_menu, header_str);
+out:
+	eficonfig_destroy(efi_menu);
+
+	return ret;
+}
+
+/**
+ * fill_file_info() - fill the file info from efi_device_path structure
+ *
+ * @dp:		pointer to the device path
+ * @file_info:	pointer to the file info structure
+ * @device_dp:	pointer to the volume device path
+ */
+static void fill_file_info(struct efi_device_path *dp,
+			   struct eficonfig_select_file_info *file_info,
+			   struct efi_device_path *device_dp)
+{
+	u16 *file_str, *p;
+	struct efi_device_path *file_dp = NULL;
+
+	efi_dp_split_file_path(dp, &device_dp, &file_dp);
+	file_info->dp_volume = device_dp;
+
+	if (file_dp) {
+		file_str = efi_dp_str(file_dp);
+		/*
+		 * efi_convert_device_path_to_text() automatically adds u'/' at the
+		 * beginning of file name, remove u'/' before copying to current_path
+		 */
+		p = file_str;
+		if (p[0] == u'/')
+			p++;
+
+		u16_strcpy(file_info->current_path, p);
+		efi_free_pool(file_dp);
+		efi_free_pool(file_str);
+	}
+}
+
+/**
+ * eficonfig_edit_boot_option() - prepare boot option structure for editing
+ *
+ * Construct the boot option structure and copy the existing value
+ *
+ * @varname:		pointer to the UEFI variable name
+ * @bo:			pointer to the boot option
+ * @load_option:	pointer to the load option
+ * @load_option_size:	size of the load option
+ * @header_str:		pointer to the header string
+ * Return	:	status code
+ */
+static efi_status_t eficonfig_edit_boot_option(u16 *varname, struct eficonfig_boot_option *bo,
+					       void *load_option, efi_uintn_t load_option_size,
+					       char *header_str)
+{
+	size_t len;
+	efi_status_t ret;
+	char *tmp = NULL, *p;
+	struct efi_load_option lo = {0};
+	efi_uintn_t final_dp_size;
+	struct efi_device_path *dp = NULL;
+	efi_uintn_t size = load_option_size;
+	struct efi_device_path *final_dp = NULL;
+	struct efi_device_path *device_dp = NULL;
+	struct efi_device_path *initrd_dp = NULL;
+	struct efi_device_path *initrd_device_dp = NULL;
+
+	const struct efi_initrd_dp id_dp = {
+		.vendor = {
+			{
+			DEVICE_PATH_TYPE_MEDIA_DEVICE,
+			DEVICE_PATH_SUB_TYPE_VENDOR_PATH,
+			sizeof(id_dp.vendor),
+			},
+			EFI_INITRD_MEDIA_GUID,
+		},
+		.end = {
+			DEVICE_PATH_TYPE_END,
+			DEVICE_PATH_SUB_TYPE_END,
+			sizeof(id_dp.end),
+		}
+	};
+
+	bo->file_info.current_path = calloc(1, EFICONFIG_FILE_PATH_BUF_SIZE);
+	if (!bo->file_info.current_path) {
+		ret =  EFI_OUT_OF_RESOURCES;
+		goto out;
+	}
+
+	bo->initrd_info.current_path = calloc(1, EFICONFIG_FILE_PATH_BUF_SIZE);
+	if (!bo->file_info.current_path) {
+		ret =  EFI_OUT_OF_RESOURCES;
+		goto out;
+	}
+
+	bo->description = calloc(1, EFICONFIG_DESCRIPTION_MAX * sizeof(u16));
+	if (!bo->description) {
+		ret =  EFI_OUT_OF_RESOURCES;
+		goto out;
+	}
+
+	bo->optional_data = calloc(1, EFICONFIG_OPTIONAL_DATA_MAX * sizeof(u16));
+	if (!bo->optional_data) {
+		ret =  EFI_OUT_OF_RESOURCES;
+		goto out;
+	}
+
+	/* copy the preset value */
+	if (load_option) {
+		ret = efi_deserialize_load_option(&lo, load_option, &size);
+		if (ret != EFI_SUCCESS)
+			goto out;
+
+		if (!lo.label) {
+			ret = EFI_INVALID_PARAMETER;
+			goto out;
+		}
+		/* truncate the long label string */
+		if (u16_strlen(lo.label) >= EFICONFIG_DESCRIPTION_MAX)
+			lo.label[EFICONFIG_DESCRIPTION_MAX - 1] = u'\0';
+
+		u16_strcpy(bo->description, lo.label);
+
+		/* EFI image file path is a first instance */
+		if (lo.file_path)
+			fill_file_info(lo.file_path, &bo->file_info, device_dp);
+
+		/* Initrd file path(optional) is placed at second instance. */
+		initrd_dp = efi_dp_from_lo(&lo, &efi_lf2_initrd_guid);
+		if (initrd_dp) {
+			fill_file_info(initrd_dp, &bo->initrd_info, initrd_device_dp);
+			efi_free_pool(initrd_dp);
+		}
+
+		if (size > 0)
+			memcpy(bo->optional_data, lo.optional_data, size);
+	}
+
+	while (1) {
+		ret = eficonfig_show_boot_option(bo, header_str);
+		if (ret == EFI_SUCCESS && bo->edit_completed)
+			break;
+		if (ret == EFI_NOT_READY)
+			continue;
+		if (ret != EFI_SUCCESS)
+			goto out;
+	}
+
+	if (bo->initrd_info.dp_volume) {
+		dp = create_selected_device_path(&bo->initrd_info);
+		if (!dp) {
+			ret = EFI_OUT_OF_RESOURCES;
+			goto out;
+		}
+		initrd_dp = efi_dp_append((const struct efi_device_path *)&id_dp, dp);
+		efi_free_pool(dp);
+	}
+
+	dp = create_selected_device_path(&bo->file_info);
+	if (!dp) {
+		ret = EFI_OUT_OF_RESOURCES;
+		goto out;
+	}
+	final_dp_size = efi_dp_size(dp) + sizeof(END);
+	if (initrd_dp) {
+		final_dp = efi_dp_concat(dp, initrd_dp);
+		final_dp_size += efi_dp_size(initrd_dp) + sizeof(END);
+	} else {
+		final_dp = efi_dp_dup(dp);
+	}
+	efi_free_pool(dp);
+
+	if (!final_dp)
+		goto out;
+
+	if (utf16_utf8_strlen(bo->optional_data)) {
+		len = utf16_utf8_strlen(bo->optional_data) + 1;
+		tmp = calloc(1, len);
+		if (!tmp)
+			goto out;
+		p = tmp;
+		utf16_utf8_strncpy(&p, bo->optional_data, u16_strlen(bo->optional_data));
+	}
+
+	ret = eficonfig_set_boot_option(varname, final_dp, final_dp_size, bo->description, tmp);
+	if (ret != EFI_SUCCESS)
+		goto out;
+out:
+	free(tmp);
+	free(bo->optional_data);
+	free(bo->description);
+	free(bo->file_info.current_path);
+	free(bo->initrd_info.current_path);
+	efi_free_pool(device_dp);
+	efi_free_pool(initrd_device_dp);
+	efi_free_pool(initrd_dp);
+	efi_free_pool(final_dp);
+
+	return ret;
+}
+
+/**
+ * eficonfig_process_add_boot_option() - handler to add boot option
+ *
+ * @data:	pointer to the data for each entry
+ * Return:	status code
+ */
+static efi_status_t eficonfig_process_add_boot_option(void *data)
+{
+	u16 varname[9];
+	efi_status_t ret;
+	struct eficonfig_boot_option *bo = NULL;
+
+	bo = calloc(1, sizeof(struct eficonfig_boot_option));
+	if (!bo)
+		return EFI_OUT_OF_RESOURCES;
+
+	ret = eficonfig_get_unused_bootoption(varname, sizeof(varname), &bo->boot_index);
+	if (ret != EFI_SUCCESS)
+		return ret;
+
+	ret = eficonfig_edit_boot_option(varname, bo, NULL, 0,  "  ** Add Boot Option ** ");
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = eficonfig_append_bootorder((u16)bo->boot_index);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+out:
+	free(bo);
+
+	/* to stay the parent menu */
+	ret = (ret == EFI_ABORTED) ? EFI_SUCCESS : ret;
+
+	return ret;
+}
+
+/**
+ * eficonfig_process_boot_selected() - handler to select boot option entry
+ *
+ * @data:	pointer to the data for each entry
+ * Return:	status code
+ */
+static efi_status_t eficonfig_process_boot_selected(void *data)
+{
+	struct eficonfig_boot_selection_data *info = data;
+
+	if (info)
+		*info->selected = info->boot_index;
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * search_bootorder() - search the boot option index in BootOrder
+ *
+ * @bootorder:	pointer to the BootOrder variable
+ * @num:	number of BootOrder entry
+ * @target:	target boot option index to search
+ * @index:	pointer to store the index of BootOrder variable
+ * Return:	true if exists, false otherwise
+ */
+static bool search_bootorder(u16 *bootorder, efi_uintn_t num, u32 target, u32 *index)
+{
+	u32 i;
+
+	for (i = 0; i < num; i++) {
+		if (target == bootorder[i]) {
+			if (index)
+				*index = i;
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * eficonfig_add_boot_selection_entry() - add boot option menu entry
+ *
+ * @efi_menu:	pointer to store the efimenu structure
+ * @boot_index:	boot option index to be added
+ * @selected:	pointer to store the selected boot option index
+ * Return:	status code
+ */
+static efi_status_t eficonfig_add_boot_selection_entry(struct efimenu *efi_menu,
+						       unsigned int boot_index,
+						       unsigned int *selected)
+{
+	char *buf, *p;
+	efi_status_t ret;
+	efi_uintn_t size;
+	void *load_option;
+	struct efi_load_option lo;
+	u16 varname[] = u"Boot####";
+	struct eficonfig_boot_selection_data *info;
+
+	efi_create_indexed_name(varname, sizeof(varname), "Boot", boot_index);
+	load_option = efi_get_var(varname, &efi_global_variable_guid, &size);
+	if (!load_option)
+		return EFI_SUCCESS;
+
+	ret = efi_deserialize_load_option(&lo, load_option, &size);
+	if (ret != EFI_SUCCESS) {
+		log_warning("Invalid load option for %ls\n", varname);
+		free(load_option);
+		return ret;
+	}
+
+	if (size >= sizeof(efi_guid_t) &&
+	    !guidcmp(lo.optional_data, &efi_guid_bootmenu_auto_generated)) {
+		/*
+		 * auto generated entry has GUID in optional_data,
+		 * skip auto generated entry because it will be generated
+		 * again even if it is edited or deleted.
+		 */
+		free(load_option);
+		return EFI_SUCCESS;
+	}
+
+	info = calloc(1, sizeof(struct eficonfig_boot_selection_data));
+	if (!info) {
+		free(load_option);
+		return EFI_OUT_OF_RESOURCES;
+	}
+
+	buf = calloc(1, utf16_utf8_strlen(lo.label) + 1);
+	if (!buf) {
+		free(load_option);
+		free(info);
+		return EFI_OUT_OF_RESOURCES;
+	}
+	p = buf;
+	utf16_utf8_strcpy(&p, lo.label);
+	info->boot_index = boot_index;
+	info->selected = selected;
+	ret = append_entry(efi_menu, buf, eficonfig_process_boot_selected, info);
+	if (ret != EFI_SUCCESS) {
+		free(load_option);
+		free(info);
+		return ret;
+	}
+	free(load_option);
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * eficonfig_show_boot_selection() - construct boot option menu entry
+ *
+ * @selected:	pointer to store the selected boot option index
+ * Return:	status code
+ */
+static efi_status_t eficonfig_show_boot_selection(unsigned int *selected)
+{
+	u32 i;
+	u16 *bootorder;
+	efi_status_t ret;
+	efi_uintn_t num, size;
+	struct efimenu *efi_menu;
+	struct list_head *pos, *n;
+	struct eficonfig_entry *entry;
+
+	efi_menu = calloc(1, sizeof(struct efimenu));
+	if (!efi_menu)
+		return EFI_OUT_OF_RESOURCES;
+
+	bootorder = efi_get_var(u"BootOrder", &efi_global_variable_guid, &size);
+
+	INIT_LIST_HEAD(&efi_menu->list);
+	num = size / sizeof(u16);
+	/* list the load option in the order of BootOrder variable */
+	for (i = 0; i < num; i++) {
+		ret = eficonfig_add_boot_selection_entry(efi_menu, bootorder[i], selected);
+		if (ret != EFI_SUCCESS)
+			goto out;
+
+		if (efi_menu->count >= EFICONFIG_ENTRY_NUM_MAX - 1)
+			break;
+	}
+
+	/* list the remaining load option not included in the BootOrder */
+	for (i = 0; i <= 0xFFFF; i++) {
+		/* If the index is included in the BootOrder, skip it */
+		if (search_bootorder(bootorder, num, i, NULL))
+			continue;
+
+		ret = eficonfig_add_boot_selection_entry(efi_menu, i, selected);
+		if (ret != EFI_SUCCESS)
+			goto out;
+
+		if (efi_menu->count >= EFICONFIG_ENTRY_NUM_MAX - 1)
+			break;
+	}
+
+	ret = append_quit_entry(efi_menu);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = eficonfig_process_common(efi_menu, "  ** Select Boot Option **");
+out:
+	list_for_each_safe(pos, n, &efi_menu->list) {
+		entry = list_entry(pos, struct eficonfig_entry, list);
+		free(entry->data);
+	}
+	eficonfig_destroy(efi_menu);
+
+	return ret;
+}
+
+/**
+ * eficonfig_process_edit_boot_option() - handler to edit boot option
+ *
+ * @data:	pointer to the data for each entry
+ * Return:	status code
+ */
+static efi_status_t eficonfig_process_edit_boot_option(void *data)
+{
+	efi_status_t ret;
+	efi_uintn_t size;
+	struct eficonfig_boot_option *bo = NULL;
+
+	while (1) {
+		unsigned int selected;
+		void *load_option;
+		u16 varname[] = u"Boot####";
+
+		ret = eficonfig_show_boot_selection(&selected);
+		if (ret != EFI_SUCCESS)
+			break;
+
+		bo = calloc(1, sizeof(struct eficonfig_boot_option));
+		if (!bo) {
+			ret = EFI_OUT_OF_RESOURCES;
+			goto out;
+		}
+
+		bo->boot_index = selected;
+		efi_create_indexed_name(varname, sizeof(varname), "Boot", selected);
+		load_option = efi_get_var(varname, &efi_global_variable_guid, &size);
+		if (!load_option) {
+			free(bo);
+			ret = EFI_NOT_FOUND;
+			goto out;
+		}
+
+		ret = eficonfig_edit_boot_option(varname, bo, load_option, size,
+						 "  ** Edit Boot Option ** ");
+
+		free(load_option);
+		free(bo);
+		if (ret != EFI_SUCCESS && ret != EFI_ABORTED)
+			break;
+	}
+out:
+	/* to stay the parent menu */
+	ret = (ret == EFI_ABORTED) ? EFI_NOT_READY : ret;
+
+	return ret;
+}
+
+/**
+ * eficonfig_display_change_boot_order() - display the BootOrder list
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ * Return:	status code
+ */
+static void eficonfig_display_change_boot_order(struct efimenu *efi_menu)
+{
+	bool reverse;
+	struct list_head *pos, *n;
+	struct eficonfig_boot_order *entry;
+
+	printf(ANSI_CLEAR_CONSOLE ANSI_CURSOR_POSITION
+	       "\n  ** Change Boot Order **\n"
+	       ANSI_CURSOR_POSITION
+	       "  Press UP/DOWN to move, +/- to change order"
+	       ANSI_CURSOR_POSITION
+	       "  Press SPACE to activate or deactivate the entry"
+	       ANSI_CURSOR_POSITION
+	       "  Select [Save] to complete, ESC/CTRL+C to quit"
+	       ANSI_CURSOR_POSITION ANSI_CLEAR_LINE,
+	       1, 1, efi_menu->count + 5, 1, efi_menu->count + 6, 1,
+	       efi_menu->count + 7, 1,  efi_menu->count + 8, 1);
+
+	/* draw boot option list */
+	list_for_each_safe(pos, n, &efi_menu->list) {
+		entry = list_entry(pos, struct eficonfig_boot_order, list);
+		reverse = (entry->num == efi_menu->active);
+
+		printf(ANSI_CURSOR_POSITION, entry->num + 4, 7);
+
+		if (reverse)
+			puts(ANSI_COLOR_REVERSE);
+
+		if (entry->num < efi_menu->count - 2) {
+			if (entry->active)
+				printf("[*]  ");
+			else
+				printf("[ ]  ");
+		}
+
+		printf("%ls", entry->description);
+
+		if (reverse)
+			puts(ANSI_COLOR_RESET);
+	}
+}
+
+/**
+ * eficonfig_choice_change_boot_order() - handle the BootOrder update
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ * Return:	status code
+ */
+static efi_status_t eficonfig_choice_change_boot_order(struct efimenu *efi_menu)
+{
+	int esc = 0;
+	struct list_head *pos, *n;
+	struct eficonfig_boot_order *tmp;
+	enum bootmenu_key key = KEY_NONE;
+	struct eficonfig_boot_order *entry;
+
+	while (1) {
+		bootmenu_loop(NULL, &key, &esc);
+
+		switch (key) {
+		case KEY_PLUS:
+			if (efi_menu->active > 0) {
+				list_for_each_safe(pos, n, &efi_menu->list) {
+					entry = list_entry(pos, struct eficonfig_boot_order, list);
+					if (entry->num == efi_menu->active)
+						break;
+				}
+				tmp = list_entry(pos->prev, struct eficonfig_boot_order, list);
+				entry->num--;
+				tmp->num++;
+				list_del(&tmp->list);
+				list_add(&tmp->list, &entry->list);
+			}
+			fallthrough;
+		case KEY_UP:
+			if (efi_menu->active > 0)
+				--efi_menu->active;
+			return EFI_NOT_READY;
+		case KEY_MINUS:
+			if (efi_menu->active < efi_menu->count - 3) {
+				list_for_each_safe(pos, n, &efi_menu->list) {
+					entry = list_entry(pos, struct eficonfig_boot_order, list);
+					if (entry->num == efi_menu->active)
+						break;
+				}
+				tmp = list_entry(pos->next, struct eficonfig_boot_order, list);
+				entry->num++;
+				tmp->num--;
+				list_del(&entry->list);
+				list_add(&entry->list, &tmp->list);
+
+				++efi_menu->active;
+			}
+			return EFI_NOT_READY;
+		case KEY_DOWN:
+			if (efi_menu->active < efi_menu->count - 1)
+				++efi_menu->active;
+			return EFI_NOT_READY;
+		case KEY_SELECT:
+			/* "Save" */
+			if (efi_menu->active == efi_menu->count - 2)
+				return EFI_SUCCESS;
+
+			/* "Quit" */
+			if (efi_menu->active == efi_menu->count - 1)
+				return EFI_ABORTED;
+
+			break;
+		case KEY_SPACE:
+			if (efi_menu->active < efi_menu->count - 2) {
+				list_for_each_safe(pos, n, &efi_menu->list) {
+					entry = list_entry(pos, struct eficonfig_boot_order, list);
+					if (entry->num == efi_menu->active) {
+						entry->active = entry->active ? false : true;
+						return EFI_NOT_READY;
+					}
+				}
+			}
+			break;
+		case KEY_QUIT:
+			return EFI_ABORTED;
+		default:
+			/* Pressed key is not valid, no need to regenerate the menu */
+			break;
+		}
+	}
+}
+
+/**
+ * eficonfig_add_change_boot_order_entry() - add boot order entry
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ * @boot_index:	boot option index to be added
+ * @active:	flag to include the boot option into BootOrder
+ * Return:	status code
+ */
+static efi_status_t eficonfig_add_change_boot_order_entry(struct efimenu *efi_menu,
+							  u32 boot_index, bool active)
+{
+	efi_status_t ret;
+	efi_uintn_t size;
+	void *load_option;
+	struct efi_load_option lo;
+	u16 varname[] = u"Boot####";
+	struct eficonfig_boot_order *entry;
+
+	efi_create_indexed_name(varname, sizeof(varname), "Boot", boot_index);
+	load_option = efi_get_var(varname, &efi_global_variable_guid, &size);
+	if (!load_option)
+		return EFI_SUCCESS;
+
+	ret = efi_deserialize_load_option(&lo, load_option, &size);
+	if (ret != EFI_SUCCESS) {
+		free(load_option);
+		return ret;
+	}
+
+	entry = calloc(1, sizeof(struct eficonfig_boot_order));
+	if (!entry) {
+		free(load_option);
+		return EFI_OUT_OF_RESOURCES;
+	}
+
+	entry->description = u16_strdup(lo.label);
+	if (!entry->description) {
+		free(load_option);
+		free(entry);
+		return EFI_OUT_OF_RESOURCES;
+	}
+	entry->num = efi_menu->count++;
+	entry->boot_index = boot_index;
+	entry->active = active;
+	list_add_tail(&entry->list, &efi_menu->list);
+
+	free(load_option);
+
+	return EFI_SUCCESS;
+}
+
+/**
+ * eficonfig_create_change_boot_order_entry() - create boot order entry
+ *
+ * @efi_menu:	pointer to the efimenu structure
+ * @bootorder:	pointer to the BootOrder variable
+ * @num:	number of BootOrder entry
+ * Return:	status code
+ */
+static efi_status_t eficonfig_create_change_boot_order_entry(struct efimenu *efi_menu,
+							     u16 *bootorder, efi_uintn_t num)
+{
+	u32 i;
+	efi_status_t ret;
+	struct eficonfig_boot_order *entry;
+
+	/* list the load option in the order of BootOrder variable */
+	for (i = 0; i < num; i++) {
+		if (efi_menu->count >= EFICONFIG_ENTRY_NUM_MAX - 2)
+			break;
+
+		ret = eficonfig_add_change_boot_order_entry(efi_menu, bootorder[i], true);
+		if (ret != EFI_SUCCESS)
+			goto out;
+	}
+
+	/* list the remaining load option not included in the BootOrder */
+	for (i = 0; i < 0xFFFF; i++) {
+		if (efi_menu->count >= EFICONFIG_ENTRY_NUM_MAX - 2)
+			break;
+
+		/* If the index is included in the BootOrder, skip it */
+		if (search_bootorder(bootorder, num, i, NULL))
+			continue;
+
+		ret = eficonfig_add_change_boot_order_entry(efi_menu, i, false);
+		if (ret != EFI_SUCCESS)
+			goto out;
+	}
+
+	/* add "Save" and "Quit" entries */
+	entry = calloc(1, sizeof(struct eficonfig_boot_order));
+	if (!entry)
+		goto out;
+
+	entry->num = efi_menu->count++;
+	entry->description = u16_strdup(u"Save");
+	list_add_tail(&entry->list, &efi_menu->list);
+
+	entry = calloc(1, sizeof(struct eficonfig_boot_order));
+	if (!entry)
+		goto out;
+
+	entry->num = efi_menu->count++;
+	entry->description = u16_strdup(u"Quit");
+	list_add_tail(&entry->list, &efi_menu->list);
+
+	efi_menu->active = 0;
+
+	return EFI_SUCCESS;
+out:
+	return EFI_OUT_OF_RESOURCES;
+}
+
+/**
+ * eficonfig_process_change_boot_order() - handler to change boot order
+ *
+ * @data:	pointer to the data for each entry
+ * Return:	status code
+ */
+static efi_status_t eficonfig_process_change_boot_order(void *data)
+{
+	u32 count;
+	u16 *bootorder;
+	efi_status_t ret;
+	efi_uintn_t num, size;
+	struct list_head *pos, *n;
+	struct eficonfig_boot_order *entry;
+	struct efimenu *efi_menu;
+
+	efi_menu = calloc(1, sizeof(struct efimenu));
+	if (!efi_menu)
+		return EFI_OUT_OF_RESOURCES;
+
+	bootorder = efi_get_var(u"BootOrder", &efi_global_variable_guid, &size);
+
+	INIT_LIST_HEAD(&efi_menu->list);
+	num = size / sizeof(u16);
+	ret = eficonfig_create_change_boot_order_entry(efi_menu, bootorder, num);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	while (1) {
+		eficonfig_display_change_boot_order(efi_menu);
+
+		ret = eficonfig_choice_change_boot_order(efi_menu);
+		if (ret == EFI_SUCCESS) {
+			u16 *new_bootorder;
+
+			new_bootorder = calloc(1, (efi_menu->count - 2) * sizeof(u16));
+			if (!new_bootorder) {
+				ret = EFI_OUT_OF_RESOURCES;
+				goto out;
+			}
+
+			/* create new BootOrder  */
+			count = 0;
+			list_for_each_safe(pos, n, &efi_menu->list) {
+				entry = list_entry(pos, struct eficonfig_boot_order, list);
+				if (entry->active)
+					new_bootorder[count++] = entry->boot_index;
+			}
+
+			size = count * sizeof(u16);
+			ret = efi_set_variable_int(u"BootOrder", &efi_global_variable_guid,
+						   EFI_VARIABLE_NON_VOLATILE |
+						   EFI_VARIABLE_BOOTSERVICE_ACCESS |
+						   EFI_VARIABLE_RUNTIME_ACCESS,
+						   size, new_bootorder, false);
+
+			free(new_bootorder);
+			goto out;
+		} else if (ret == EFI_NOT_READY) {
+			continue;
+		} else {
+			goto out;
+		}
+	}
+out:
+	list_for_each_safe(pos, n, &efi_menu->list) {
+		entry = list_entry(pos, struct eficonfig_boot_order, list);
+		list_del(&entry->list);
+		free(entry->description);
+		free(entry);
+	}
+
+	free(bootorder);
+	free(efi_menu);
+
+	/* to stay the parent menu */
+	ret = (ret == EFI_ABORTED) ? EFI_NOT_READY : ret;
+
+	return ret;
+}
+
+/**
+ * delete_boot_option() - delete selected boot option
+ *
+ * @boot_index:	boot option index to delete
+ * Return:	status code
+ */
+static efi_status_t delete_boot_option(u16 boot_index)
+{
+	u16 *bootorder;
+	u16 varname[9];
+	efi_status_t ret;
+	unsigned int index;
+	efi_uintn_t num, size;
+
+	efi_create_indexed_name(varname, sizeof(varname),
+				"Boot", boot_index);
+	ret = efi_set_variable_int(varname, &efi_global_variable_guid,
+				   0, 0, NULL, false);
+	if (ret != EFI_SUCCESS) {
+		log_err("delete boot option(%ls) failed\n", varname);
+		return ret;
+	}
+
+	/* update BootOrder if necessary */
+	bootorder = efi_get_var(u"BootOrder", &efi_global_variable_guid, &size);
+	if (!bootorder)
+		return EFI_SUCCESS;
+
+	num = size / sizeof(u16);
+	if (!search_bootorder(bootorder, num, boot_index, &index))
+		return EFI_SUCCESS;
+
+	memmove(&bootorder[index], &bootorder[index + 1],
+		(num - index - 1) * sizeof(u16));
+	size -= sizeof(u16);
+	ret = efi_set_variable_int(u"BootOrder", &efi_global_variable_guid,
+				   EFI_VARIABLE_NON_VOLATILE |
+				   EFI_VARIABLE_BOOTSERVICE_ACCESS |
+				   EFI_VARIABLE_RUNTIME_ACCESS,
+				   size, bootorder, false);
+
+	return ret;
+}
+
+/**
+ * eficonfig_process_delete_boot_option() - handler to delete boot option
+ *
+ * @data:	pointer to the data for each entry
+ * Return:	status code
+ */
+static efi_status_t eficonfig_process_delete_boot_option(void *data)
+{
+	efi_status_t ret;
+	unsigned int selected;
+
+	while (1) {
+		ret = eficonfig_show_boot_selection(&selected);
+		if (ret == EFI_SUCCESS)
+			ret = delete_boot_option(selected);
+
+		if (ret != EFI_SUCCESS)
+			break;
+	}
+
+	/* to stay the parent menu */
+	ret = (ret == EFI_ABORTED) ? EFI_NOT_READY : ret;
+
+	return ret;
+}
+
+/**
+ * eficonfig_enumerate_boot_option() - enumerate the possible bootable media
+ *
+ * @opt:		pointer to the media boot option structure
+ * @volume_handles:	pointer to the efi handles
+ * @count:		number of efi handle
+ * Return:		status code
+ */
+efi_status_t eficonfig_enumerate_boot_option(struct eficonfig_media_boot_option *opt,
+					     efi_handle_t *volume_handles, efi_status_t count)
+{
+	u32 i;
+	struct efi_handler *handler;
+	efi_status_t ret = EFI_SUCCESS;
+
+	for (i = 0; i < count; i++) {
+		u16 *p;
+		u16 dev_name[BOOTMENU_DEVICE_NAME_MAX];
+		char *optional_data;
+		struct efi_load_option lo;
+		char buf[BOOTMENU_DEVICE_NAME_MAX];
+		struct efi_device_path *device_path;
+
+		ret = efi_search_protocol(volume_handles[i], &efi_guid_device_path, &handler);
+		if (ret != EFI_SUCCESS)
+			continue;
+		ret = efi_protocol_open(handler, (void **)&device_path,
+					efi_root, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+		if (ret != EFI_SUCCESS)
+			continue;
+
+		ret = efi_disk_get_device_name(volume_handles[i], buf, BOOTMENU_DEVICE_NAME_MAX);
+		if (ret != EFI_SUCCESS)
+			continue;
+
+		p = dev_name;
+		utf8_utf16_strncpy(&p, buf, strlen(buf));
+
+		lo.label = dev_name;
+		lo.attributes = LOAD_OPTION_ACTIVE;
+		lo.file_path = device_path;
+		lo.file_path_length = efi_dp_size(device_path) + sizeof(END);
+		/*
+		 * Set the dedicated guid to optional_data, it is used to identify
+		 * the boot option that automatically generated by the bootmenu.
+		 * efi_serialize_load_option() expects optional_data is null-terminated
+		 * utf8 string, so set the "1234567" string to allocate enough space
+		 * to store guid, instead of realloc the load_option.
+		 */
+		lo.optional_data = "1234567";
+		opt[i].size = efi_serialize_load_option(&lo, (u8 **)&opt[i].lo);
+		if (!opt[i].size) {
+			ret = EFI_OUT_OF_RESOURCES;
+			goto out;
+		}
+		/* set the guid */
+		optional_data = (char *)opt[i].lo + (opt[i].size - u16_strsize(u"1234567"));
+		memcpy(optional_data, &efi_guid_bootmenu_auto_generated, sizeof(efi_guid_t));
+	}
+
+out:
+	return ret;
+}
+
+/**
+ * eficonfig_delete_invalid_boot_option() - delete non-existing boot option
+ *
+ * @opt:		pointer to the media boot option structure
+ * @count:		number of media boot option structure
+ * Return:		status code
+ */
+efi_status_t eficonfig_delete_invalid_boot_option(struct eficonfig_media_boot_option *opt,
+						  efi_status_t count)
+{
+	u32 i, j;
+	efi_uintn_t size;
+	efi_status_t ret;
+	void *load_option;
+	struct efi_load_option lo;
+	u16 varname[] = u"Boot####";
+
+	for (i = 0; i <= 0xFFFF; i++) {
+		efi_uintn_t tmp;
+
+		efi_create_indexed_name(varname, sizeof(varname), "Boot", i);
+		load_option = efi_get_var(varname, &efi_global_variable_guid, &size);
+		if (!load_option)
+			continue;
+
+		tmp = size;
+		ret = efi_deserialize_load_option(&lo, load_option, &size);
+		if (ret != EFI_SUCCESS)
+			goto next;
+
+		if (size >= sizeof(efi_guid_bootmenu_auto_generated)) {
+			if (guidcmp(lo.optional_data, &efi_guid_bootmenu_auto_generated) == 0) {
+				for (j = 0; j < count; j++) {
+					if (opt[j].size == tmp &&
+					    memcmp(opt[j].lo, load_option, tmp) == 0) {
+						opt[j].exist = true;
+						break;
+					}
+				}
+
+				if (j == count) {
+					ret = delete_boot_option(i);
+					if (ret != EFI_SUCCESS) {
+						free(load_option);
+						goto out;
+					}
+				}
+			}
+		}
+next:
+		free(load_option);
+	}
+
+out:
+	return ret;
+}
+
+/**
+ * eficonfig_generate_media_device_boot_option() - generate the media device boot option
+ *
+ * This function enumerates all devices supporting EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
+ * and generate the bootmenu entries.
+ * This function also provide the BOOT#### variable maintenance for
+ * the media device entries.
+ *   - Automatically create the BOOT#### variable for the newly detected device,
+ *     this BOOT#### variable is distinguished by the special GUID
+ *     stored in the EFI_LOAD_OPTION.optional_data
+ *   - If the device is not attached to the system, the associated BOOT#### variable
+ *     is automatically deleted.
+ *
+ * Return:	status code
+ */
+efi_status_t eficonfig_generate_media_device_boot_option(void)
+{
+	u32 i;
+	efi_status_t ret;
+	efi_uintn_t count;
+	efi_handle_t *volume_handles = NULL;
+	struct eficonfig_media_boot_option *opt = NULL;
+
+	ret = efi_locate_handle_buffer_int(BY_PROTOCOL, &efi_simple_file_system_protocol_guid,
+					   NULL, &count, (efi_handle_t **)&volume_handles);
+	if (ret != EFI_SUCCESS)
+		return ret;
+
+	opt = calloc(count, sizeof(struct eficonfig_media_boot_option));
+	if (!opt)
+		goto out;
+
+	/* enumerate all devices supporting EFI_SIMPLE_FILE_SYSTEM_PROTOCOL */
+	ret = eficonfig_enumerate_boot_option(opt, volume_handles, count);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	/*
+	 * System hardware configuration may vary depending on the user setup.
+	 * The boot option is automatically added by the bootmenu.
+	 * If the device is not attached to the system, the boot option needs
+	 * to be deleted.
+	 */
+	ret = eficonfig_delete_invalid_boot_option(opt, count);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	/* add non-existent boot option */
+	for (i = 0; i < count; i++) {
+		u32 boot_index;
+		u16 var_name[9];
+
+		if (!opt[i].exist) {
+			ret = eficonfig_get_unused_bootoption(var_name, sizeof(var_name),
+							      &boot_index);
+			if (ret != EFI_SUCCESS)
+				goto out;
+
+			ret = efi_set_variable_int(var_name, &efi_global_variable_guid,
+						   EFI_VARIABLE_NON_VOLATILE |
+						   EFI_VARIABLE_BOOTSERVICE_ACCESS |
+						   EFI_VARIABLE_RUNTIME_ACCESS,
+						   opt[i].size, opt[i].lo, false);
+			if (ret != EFI_SUCCESS)
+				goto out;
+
+			ret = eficonfig_append_bootorder(boot_index);
+			if (ret != EFI_SUCCESS) {
+				efi_set_variable_int(var_name, &efi_global_variable_guid,
+						     0, 0, NULL, false);
+				goto out;
+			}
+		}
+	}
+
+out:
+	if (opt) {
+		for (i = 0; i < count; i++)
+			free(opt[i].lo);
+	}
+	free(opt);
+	efi_free_pool(volume_handles);
+
+	return ret;
+}
+
+/**
+ * eficonfig_init() - do required initialization for eficonfig command
+ *
+ * Return:	status code
+ */
+static efi_status_t eficonfig_init(void)
+{
+	efi_status_t ret = EFI_SUCCESS;
+	static bool init;
+	struct efi_handler *handler;
+
+	if (!init) {
+		ret = efi_search_protocol(efi_root, &efi_guid_text_input_protocol, &handler);
+		if (ret != EFI_SUCCESS)
+			return ret;
+
+		ret = efi_protocol_open(handler, (void **)&cin, efi_root, NULL,
+					EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+		if (ret != EFI_SUCCESS)
+			return ret;
+	}
+
+	init = true;
+
+	return ret;
+}
+
+static const struct eficonfig_item maintenance_menu_items[] = {
+	{"Add Boot Option", eficonfig_process_add_boot_option},
+	{"Edit Boot Option", eficonfig_process_edit_boot_option},
+	{"Change Boot Order", eficonfig_process_change_boot_order},
+	{"Delete Boot Option", eficonfig_process_delete_boot_option},
+	{"Quit", eficonfig_process_quit},
+};
+
+/**
+ * do_eficonfig() - execute `eficonfig` command
+ *
+ * @cmdtp:	table entry describing command
+ * @flag:	bitmap indicating how the command was invoked
+ * @argc:	number of arguments
+ * @argv:	command line arguments
+ * Return:	status code
+ */
+static int do_eficonfig(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
+{
+	efi_status_t ret;
+	struct efimenu *efi_menu;
+
+	if (argc > 1)
+		return CMD_RET_USAGE;
+
+	ret = efi_init_obj_list();
+	if (ret != EFI_SUCCESS) {
+		log_err("Error: Cannot initialize UEFI sub-system, r = %lu\n",
+			ret & ~EFI_ERROR_MASK);
+
+		return CMD_RET_FAILURE;
+	}
+
+	ret = eficonfig_init();
+	if (ret != EFI_SUCCESS)
+		return CMD_RET_FAILURE;
+
+	ret = eficonfig_generate_media_device_boot_option();
+	if (ret != EFI_SUCCESS && ret != EFI_NOT_FOUND)
+		return ret;
+
+	while (1) {
+		efi_menu = eficonfig_create_fixed_menu(maintenance_menu_items,
+						       ARRAY_SIZE(maintenance_menu_items));
+		if (!efi_menu)
+			return CMD_RET_FAILURE;
+
+		ret = eficonfig_process_common(efi_menu, "  ** UEFI Maintenance Menu **");
+		eficonfig_destroy(efi_menu);
+
+		if (ret == EFI_ABORTED)
+			break;
+	}
+
+	return CMD_RET_SUCCESS;
+}
+
+U_BOOT_CMD(
+	eficonfig, 1, 0, do_eficonfig,
+	"provide menu-driven UEFI variable maintenance interface",
+	""
+);
diff --git a/cmd/elf.c b/cmd/elf.c
index ce40d3f72a7..b7b9f506a52 100644
--- a/cmd/elf.c
+++ b/cmd/elf.c
@@ -72,6 +72,7 @@ int do_bootelf(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 		return rcode;
 
 	printf("## Starting application at 0x%08lx ...\n", addr);
+	flush();
 
 	/*
 	 * pass address parameter as argv[0] (aka command name),
@@ -274,6 +275,7 @@ int do_bootvx(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 		puts("## Not an ELF image, assuming binary\n");
 
 	printf("## Starting vxWorks at 0x%08lx ...\n", addr);
+	flush();
 
 	dcache_disable();
 #if defined(CONFIG_ARM64) && defined(CONFIG_ARMV8_PSCI)
diff --git a/cmd/fastboot.c b/cmd/fastboot.c
index 033a2c95e8f..dd223b1554d 100644
--- a/cmd/fastboot.c
+++ b/cmd/fastboot.c
@@ -76,7 +76,7 @@ static int do_fastboot_usb(int argc, char *const argv[],
 			break;
 		if (ctrlc())
 			break;
-		WATCHDOG_RESET();
+		schedule();
 		usb_gadget_handle_interrupts(controller_index);
 	}
 
diff --git a/cmd/fpga.c b/cmd/fpga.c
index 9cf7651d8c5..8c64e957db0 100644
--- a/cmd/fpga.c
+++ b/cmd/fpga.c
@@ -288,7 +288,7 @@ static int do_fpga_loadmk(struct cmd_tbl *cmdtp, int flag, int argc,
 #if defined(CONFIG_LEGACY_IMAGE_FORMAT)
 	case IMAGE_FORMAT_LEGACY:
 	{
-		image_header_t *hdr = (image_header_t *)fpga_data;
+		struct legacy_img_hdr *hdr = (struct legacy_img_hdr *)fpga_data;
 		ulong data;
 		u8 comp;
 
diff --git a/cmd/ide.c b/cmd/ide.c
index b78c38e1590..6739f0b12d1 100644
--- a/cmd/ide.c
+++ b/cmd/ide.c
@@ -37,7 +37,7 @@ int do_ide(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 		}
 	}
 
-	return blk_common_cmd(argc, argv, IF_TYPE_IDE, &curr_device);
+	return blk_common_cmd(argc, argv, UCLASS_IDE, &curr_device);
 }
 
 int do_diskboot(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
diff --git a/cmd/load.c b/cmd/load.c
index e44ae0d56b7..5c4f34781d4 100644
--- a/cmd/load.c
+++ b/cmd/load.c
@@ -83,6 +83,7 @@ static int do_load_serial(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ENTER ...\n",
 			load_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = load_baudrate;
 		serial_setbrg();
 		udelay(50000);
@@ -126,6 +127,7 @@ static int do_load_serial(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ESC ...\n",
 			current_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = current_baudrate;
 		serial_setbrg();
 		udelay(50000);
@@ -317,6 +319,7 @@ int do_save_serial(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ESC ...\n",
 			(int)current_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = current_baudrate;
 		serial_setbrg();
 		udelay(50000);
@@ -471,6 +474,7 @@ static int do_load_serial_bin(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ENTER ...\n",
 			load_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = load_baudrate;
 		serial_setbrg();
 		udelay(50000);
@@ -533,6 +537,7 @@ static int do_load_serial_bin(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ESC ...\n",
 			current_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = current_baudrate;
 		serial_setbrg();
 		udelay(50000);
diff --git a/cmd/lsblk.c b/cmd/lsblk.c
index 6a1c8f5ef40..d214dafc3be 100644
--- a/cmd/lsblk.c
+++ b/cmd/lsblk.c
@@ -36,7 +36,7 @@ static int do_lsblk(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv
 				continue;
 			desc = dev_get_uclass_plat(udev);
 			printf("%c %s %u", i ? ',' : ':',
-			       blk_get_if_type_name(desc->if_type),
+			       blk_get_uclass_name(desc->uclass_id),
 			       desc->devnum);
 			i++;
 		}
diff --git a/cmd/mem.c b/cmd/mem.c
index 6a7b4014edc..1e39348195a 100644
--- a/cmd/mem.c
+++ b/cmd/mem.c
@@ -300,7 +300,7 @@ static int do_mem_cmp(struct cmd_tbl *cmdtp, int flag, int argc,
 
 		/* reset watchdog from time to time */
 		if ((ngood % (64 << 10)) == 0)
-			WATCHDOG_RESET();
+			schedule();
 	}
 	unmap_sysmem(buf1);
 	unmap_sysmem(buf2);
@@ -848,7 +848,7 @@ static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
 		}
 	}
 	addr[test_offset] = pattern;
-	WATCHDOG_RESET();
+	schedule();
 
 	/*
 	 * Check for addr bits stuck low or shorted.
@@ -890,7 +890,7 @@ static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
 	 * Fill memory with a known pattern.
 	 */
 	for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
-		WATCHDOG_RESET();
+		schedule();
 		addr[offset] = pattern;
 	}
 
@@ -898,7 +898,7 @@ static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
 	 * Check each location and invert it for the second pass.
 	 */
 	for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
-		WATCHDOG_RESET();
+		schedule();
 		temp = addr[offset];
 		if (temp != pattern) {
 			printf("\nFAILURE (read/write) @ 0x%.8lx:"
@@ -918,7 +918,7 @@ static ulong mem_test_alt(vu_long *buf, ulong start_addr, ulong end_addr,
 	 * Check each location for the inverted pattern and zero it.
 	 */
 	for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
-		WATCHDOG_RESET();
+		schedule();
 		anti_pattern = ~pattern;
 		temp = addr[offset];
 		if (temp != anti_pattern) {
@@ -972,7 +972,7 @@ static ulong test_bitflip_comparison(volatile unsigned long *bufa,
 	for (k = 0; k < max; k++) {
 		q = 0x00000001L << k;
 		for (j = 0; j < 8; j++) {
-			WATCHDOG_RESET();
+			schedule();
 			q = ~q;
 			p1 = (volatile unsigned long *)bufa;
 			p2 = (volatile unsigned long *)bufb;
@@ -1033,7 +1033,7 @@ static ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr,
 		pattern, "");
 
 	for (addr = buf, val = pattern; addr < end; addr++) {
-		WATCHDOG_RESET();
+		schedule();
 		*addr = val;
 		val += incr;
 	}
@@ -1041,7 +1041,7 @@ static ulong mem_test_quick(vu_long *buf, ulong start_addr, ulong end_addr,
 	puts("Reading...");
 
 	for (addr = buf, val = pattern; addr < end; addr++) {
-		WATCHDOG_RESET();
+		schedule();
 		readback = *addr;
 		if (readback != val) {
 			ulong offset = addr - buf;
diff --git a/cmd/mmc.c b/cmd/mmc.c
index 7bd4cd9e016..c79d9407986 100644
--- a/cmd/mmc.c
+++ b/cmd/mmc.c
@@ -154,7 +154,7 @@ static struct mmc *__init_mmc_device(int dev, bool force_init,
 
 #ifdef CONFIG_BLOCK_CACHE
 	struct blk_desc *bd = mmc_get_blk_desc(mmc);
-	blkcache_invalidate(bd->if_type, bd->devnum);
+	blkcache_invalidate(bd->uclass_id, bd->devnum);
 #endif
 
 	return mmc;
@@ -331,13 +331,13 @@ static int do_mmcrpmb(struct cmd_tbl *cmdtp, int flag,
 #else
 	original_part = mmc_get_blk_desc(mmc)->hwpart;
 #endif
-	if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, MMC_PART_RPMB) !=
+	if (blk_select_hwpart_devnum(UCLASS_MMC, curr_device, MMC_PART_RPMB) !=
 	    0)
 		return CMD_RET_FAILURE;
 	ret = cp->cmd(cmdtp, flag, argc, argv);
 
 	/* Return to original partition */
-	if (blk_select_hwpart_devnum(IF_TYPE_MMC, curr_device, original_part) !=
+	if (blk_select_hwpart_devnum(UCLASS_MMC, curr_device, original_part) !=
 	    0)
 		return CMD_RET_FAILURE;
 	return ret;
@@ -530,7 +530,7 @@ static int do_mmc_part(struct cmd_tbl *cmdtp, int flag,
 	if (!mmc)
 		return CMD_RET_FAILURE;
 
-	mmc_dev = blk_get_devnum_by_type(IF_TYPE_MMC, curr_device);
+	mmc_dev = blk_get_devnum_by_uclass_id(UCLASS_MMC, curr_device);
 	if (mmc_dev != NULL && mmc_dev->type != DEV_TYPE_UNKNOWN) {
 		part_print(mmc_dev);
 		return CMD_RET_SUCCESS;
@@ -580,7 +580,7 @@ static int do_mmc_dev(struct cmd_tbl *cmdtp, int flag,
 	if (!mmc)
 		return CMD_RET_FAILURE;
 
-	ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
+	ret = blk_select_hwpart_devnum(UCLASS_MMC, dev, part);
 	printf("switch to partitions #%d, %s\n",
 	       part, (!ret) ? "OK" : "ERROR");
 	if (ret)
diff --git a/cmd/mvebu/bubt.c b/cmd/mvebu/bubt.c
index 7e6e47f40d6..1efbe2e607c 100644
--- a/cmd/mvebu/bubt.c
+++ b/cmd/mvebu/bubt.c
@@ -425,7 +425,7 @@ static size_t usb_read_file(const char *file_name)
 	}
 
 	/* Try to recognize storage devices immediately */
-	blk_first_device(IF_TYPE_USB, &dev);
+	blk_first_device(UCLASS_USB, &dev);
 	if (!dev) {
 		printf("Error: USB storage device not found\n");
 		return 0;
diff --git a/cmd/nand.c b/cmd/nand.c
index e730484d0b7..5bb43794e90 100644
--- a/cmd/nand.c
+++ b/cmd/nand.c
@@ -975,7 +975,7 @@ static int nand_load_image(struct cmd_tbl *cmdtp, struct mtd_info *mtd,
 	char *s;
 	size_t cnt;
 #if defined(CONFIG_LEGACY_IMAGE_FORMAT)
-	image_header_t *hdr;
+	struct legacy_img_hdr *hdr;
 #endif
 #if defined(CONFIG_FIT)
 	const void *fit_hdr = NULL;
@@ -1004,7 +1004,7 @@ static int nand_load_image(struct cmd_tbl *cmdtp, struct mtd_info *mtd,
 	switch (genimg_get_format ((void *)addr)) {
 #if defined(CONFIG_LEGACY_IMAGE_FORMAT)
 	case IMAGE_FORMAT_LEGACY:
-		hdr = (image_header_t *)addr;
+		hdr = (struct legacy_img_hdr *)addr;
 
 		bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
 		image_print_contents (hdr);
diff --git a/cmd/nvme.c b/cmd/nvme.c
index e715c570a38..09d5f438fb1 100644
--- a/cmd/nvme.c
+++ b/cmd/nvme.c
@@ -28,7 +28,7 @@ static int do_nvme(struct cmd_tbl *cmdtp, int flag, int argc,
 		if (strncmp(argv[1], "deta", 4) == 0) {
 			struct udevice *udev;
 
-			ret = blk_get_device(IF_TYPE_NVME, nvme_curr_dev,
+			ret = blk_get_device(UCLASS_NVME, nvme_curr_dev,
 					     &udev);
 			if (ret < 0)
 				return CMD_RET_FAILURE;
@@ -39,7 +39,7 @@ static int do_nvme(struct cmd_tbl *cmdtp, int flag, int argc,
 		}
 	}
 
-	return blk_common_cmd(argc, argv, IF_TYPE_NVME, &nvme_curr_dev);
+	return blk_common_cmd(argc, argv, UCLASS_NVME, &nvme_curr_dev);
 }
 
 U_BOOT_CMD(
diff --git a/cmd/pause.c b/cmd/pause.c
new file mode 100644
index 00000000000..c97833c0d70
--- /dev/null
+++ b/cmd/pause.c
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * (C) Copyright 2021
+ * Samuel Dionne-Riel <samuel@dionne-riel.com>
+ */
+
+#include <command.h>
+#include <stdio.h>
+
+static int do_pause(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
+{
+	char *message = "Press any key to continue...";
+
+	if (argc == 2)
+		message = argv[1];
+
+	/* No newline, so it sticks to the bottom of the screen */
+	printf("%s", message);
+
+	/* Wait on "any" key... */
+	(void) getchar();
+
+	/* Since there was no newline, we need it now */
+	printf("\n");
+
+	return CMD_RET_SUCCESS;
+}
+
+U_BOOT_CMD(pause, 2, 1, do_pause,
+	"delay until user input",
+	"[prompt] - Wait until users presses any key. [prompt] can be used to customize the message.\n"
+);
diff --git a/cmd/pvblock.c b/cmd/pvblock.c
index 56ce8b18d51..1b604c37373 100644
--- a/cmd/pvblock.c
+++ b/cmd/pvblock.c
@@ -14,7 +14,7 @@ static int pvblock_curr_device;
 
 int do_pvblock(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 {
-	return blk_common_cmd(argc, argv, IF_TYPE_PVBLOCK,
+	return blk_common_cmd(argc, argv, UCLASS_PVBLOCK,
 			      &pvblock_curr_device);
 }
 
diff --git a/cmd/sata.c b/cmd/sata.c
index 76da1906b7f..9c9fe111d12 100644
--- a/cmd/sata.c
+++ b/cmd/sata.c
@@ -27,7 +27,7 @@ int sata_remove(int devnum)
 	struct udevice *dev;
 	int rc;
 
-	blk_unbind_all(IF_TYPE_SATA);
+	blk_unbind_all(UCLASS_AHCI);
 
 	rc = uclass_find_device(UCLASS_AHCI, devnum, &dev);
 	if (!rc && !dev)
@@ -111,7 +111,7 @@ static int do_sata(struct cmd_tbl *cmdtp, int flag, int argc,
 		sata_curr_device = 0;
 	}
 
-	return blk_common_cmd(argc, argv, IF_TYPE_SATA, &sata_curr_device);
+	return blk_common_cmd(argc, argv, UCLASS_AHCI, &sata_curr_device);
 }
 
 U_BOOT_CMD(
diff --git a/cmd/scsi.c b/cmd/scsi.c
index 5f710d28957..4549995ba73 100644
--- a/cmd/scsi.c
+++ b/cmd/scsi.c
@@ -50,7 +50,7 @@ static int do_scsi(struct cmd_tbl *cmdtp, int flag, int argc,
 		}
 	}
 
-	return blk_common_cmd(argc, argv, IF_TYPE_SCSI, &scsi_curr_dev);
+	return blk_common_cmd(argc, argv, UCLASS_SCSI, &scsi_curr_dev);
 }
 
 U_BOOT_CMD(
diff --git a/cmd/source.c b/cmd/source.c
index 81e015b64ef..698d9f86d96 100644
--- a/cmd/source.c
+++ b/cmd/source.c
@@ -46,7 +46,7 @@ int image_source_script(ulong addr, const char *fit_uname)
 {
 	ulong		len;
 #if defined(CONFIG_LEGACY_IMAGE_FORMAT)
-	const image_header_t *hdr;
+	const struct legacy_img_hdr *hdr;
 #endif
 	u32		*data;
 	int		verify;
diff --git a/cmd/usb.c b/cmd/usb.c
index 3d873765250..2ba056982c3 100644
--- a/cmd/usb.c
+++ b/cmd/usb.c
@@ -719,7 +719,7 @@ static int do_usb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 	if (strncmp(argv[1], "stor", 4) == 0)
 		return usb_stor_info();
 
-	return blk_common_cmd(argc, argv, IF_TYPE_USB, &usb_stor_curr_dev);
+	return blk_common_cmd(argc, argv, UCLASS_USB, &usb_stor_curr_dev);
 #else
 	return CMD_RET_USAGE;
 #endif /* CONFIG_USB_STORAGE */
diff --git a/cmd/usb_mass_storage.c b/cmd/usb_mass_storage.c
index d4e619b842c..b7daaa6e8e8 100644
--- a/cmd/usb_mass_storage.c
+++ b/cmd/usb_mass_storage.c
@@ -231,7 +231,7 @@ static int do_usb_mass_storage(struct cmd_tbl *cmdtp, int flag,
 			goto cleanup_register;
 		}
 
-		WATCHDOG_RESET();
+		schedule();
 	}
 
 cleanup_register:
diff --git a/cmd/virtio.c b/cmd/virtio.c
index ea3ed2e631e..ec87d4f02c9 100644
--- a/cmd/virtio.c
+++ b/cmd/virtio.c
@@ -40,7 +40,7 @@ static int do_virtio(struct cmd_tbl *cmdtp, int flag, int argc,
 		return CMD_RET_SUCCESS;
 	}
 
-	return blk_common_cmd(argc, argv, IF_TYPE_VIRTIO, &virtio_curr_dev);
+	return blk_common_cmd(argc, argv, UCLASS_VIRTIO, &virtio_curr_dev);
 }
 
 U_BOOT_CMD(
diff --git a/cmd/ximg.c b/cmd/ximg.c
index f84141ff45c..1c40fd27a05 100644
--- a/cmd/ximg.c
+++ b/cmd/ximg.c
@@ -42,7 +42,7 @@ do_imgextract(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 	int		part = 0;
 #if defined(CONFIG_LEGACY_IMAGE_FORMAT)
 	ulong		count;
-	image_header_t	*hdr = NULL;
+	struct legacy_img_hdr	*hdr = NULL;
 #endif
 #if defined(CONFIG_FIT)
 	const char	*uname = NULL;
@@ -78,7 +78,7 @@ do_imgextract(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 		printf("## Copying part %d from legacy image "
 			"at %08lx ...\n", part, addr);
 
-		hdr = (image_header_t *)addr;
+		hdr = (struct legacy_img_hdr *)addr;
 		if (!image_check_magic(hdr)) {
 			printf("Bad Magic Number\n");
 			return 1;
@@ -197,7 +197,7 @@ do_imgextract(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 
 				while (l > 0) {
 					tail = (l > CHUNKSZ) ? CHUNKSZ : l;
-					WATCHDOG_RESET();
+					schedule();
 					memmove(to, from, tail);
 					to += tail;
 					from += tail;