Merge tag 'efi-next-2024-11-18' of https://source.denx.de/u-boot/custodians/u-boot-efi into next

CI: https://source.denx.de/u-boot/custodians/u-boot-efi/-/pipelines/23430

- Prepare for implementing the EFI_HTTP_PROTOCOL:
  - Make wget functionality callable even if the wget command is not
    built (add CONFIG_WGET symbol).
  - Ensure that wget_with_dns() works the same with the old network
    stack and with lwIP.
  - Put server_name and port into wget_ctx.
  - Integrate struct wget_info into wget code.
  - Move ip_to_string to lib/net_utils.c
diff --git a/Kconfig b/Kconfig
index eb55f25..bd63fea 100644
--- a/Kconfig
+++ b/Kconfig
@@ -595,27 +595,6 @@
 	  WARNING: Please make sure that this value is a multiple of the OS
 	  page size.
 
-config SYS_HAS_SRAM
-	bool
-	default y if TARGET_PIC32MZDASK
-	default y if TARGET_DEVKIT8000
-	help
-	  Enable this to allow support for the on board SRAM.
-	  SRAM base address is controlled by CONFIG_SYS_SRAM_BASE.
-	  SRAM size is controlled by CONFIG_SYS_SRAM_SIZE.
-
-config SYS_SRAM_BASE
-	hex
-	default 0x80000000 if TARGET_PIC32MZDASK
-	default 0x40200000 if TARGET_DEVKIT8000
-	default 0x0
-
-config SYS_SRAM_SIZE
-	hex
-	default 0x00080000 if TARGET_PIC32MZDASK
-	default 0x10000 if TARGET_DEVKIT8000
-	default 0x0
-
 config SYS_MONITOR_LEN
 	int "Maximum size in bytes reserved for U-Boot in memory"
 	default 1048576 if X86
diff --git a/api/api_platform-powerpc.c b/api/api_platform-powerpc.c
index 3a04a9f..2c1ab04 100644
--- a/api/api_platform-powerpc.c
+++ b/api/api_platform-powerpc.c
@@ -43,7 +43,6 @@
 
 	platform_set_mr(si, gd->ram_base, gd->ram_size, MR_ATTR_DRAM);
 	platform_set_mr(si, gd->bd->bi_flashstart, gd->bd->bi_flashsize, MR_ATTR_FLASH);
-	platform_set_mr(si, gd->bd->bi_sramstart, gd->bd->bi_sramsize, MR_ATTR_SRAM);
 
 	return 1;
 }
diff --git a/arch/arm/cpu/armv8/cache_v8.c b/arch/arm/cpu/armv8/cache_v8.c
index e6be635..5d6953f 100644
--- a/arch/arm/cpu/armv8/cache_v8.c
+++ b/arch/arm/cpu/armv8/cache_v8.c
@@ -825,7 +825,7 @@
 
 void dcache_disable(void)
 {
-	uint32_t sctlr;
+	unsigned long sctlr;
 
 	sctlr = get_sctlr();
 
diff --git a/arch/arm/cpu/armv8/cpu.c b/arch/arm/cpu/armv8/cpu.c
index d568efa..82ecf02 100644
--- a/arch/arm/cpu/armv8/cpu.c
+++ b/arch/arm/cpu/armv8/cpu.c
@@ -94,3 +94,8 @@
 	secure_ram_addr(psci_arch_init)();
 }
 #endif
+
+void allow_unaligned(void)
+{
+	set_sctlr(get_sctlr() & ~CR_A);
+}
diff --git a/arch/arm/include/asm/system.h b/arch/arm/include/asm/system.h
index 52f6c9b..dbf9ab4 100644
--- a/arch/arm/include/asm/system.h
+++ b/arch/arm/include/asm/system.h
@@ -171,7 +171,7 @@
 	return 3 & (el >> 2);
 }
 
-static inline unsigned int get_sctlr(void)
+static inline unsigned long get_sctlr(void)
 {
 	unsigned int el;
 	unsigned long val;
diff --git a/board/coreboot/coreboot/sysinfo.c b/board/coreboot/coreboot/sysinfo.c
index e0bdc7a..d6b1953 100644
--- a/board/coreboot/coreboot/sysinfo.c
+++ b/board/coreboot/coreboot/sysinfo.c
@@ -24,21 +24,21 @@
 	const char *str = NULL;
 
 	switch (id) {
-	case SYSINFO_ID_BOARD_MODEL:
+	case SYSID_BOARD_MODEL:
 		if (priv->t1)
 			str = smbios_string(priv->system,
 					    priv->t1->product_name);
 		break;
-	case SYSINFO_ID_BOARD_MANUFACTURER:
+	case SYSID_BOARD_MANUFACTURER:
 		if (priv->t1)
 			str = smbios_string(priv->system,
 					    priv->t1->manufacturer);
 		break;
-	case SYSINFO_ID_PRIOR_STAGE_VERSION:
+	case SYSID_PRIOR_STAGE_VERSION:
 		if (priv->t0)
 			str = smbios_string(priv->bios, priv->t0->bios_ver);
 		break;
-	case SYSINFO_ID_PRIOR_STAGE_DATE:
+	case SYSID_PRIOR_STAGE_DATE:
 		if (priv->t0)
 			str = smbios_string(priv->bios,
 					    priv->t0->bios_release_date);
diff --git a/board/google/chromebook_coral/coral.c b/board/google/chromebook_coral/coral.c
index 3443dc9..db96534 100644
--- a/board/google/chromebook_coral/coral.c
+++ b/board/google/chromebook_coral/coral.c
@@ -151,8 +151,8 @@
 		return -ENOSYS;
 
 	switch (id) {
-	case SYSINFO_ID_SMBIOS_SYSTEM_VERSION:
-	case SYSINFO_ID_SMBIOS_BASEBOARD_VERSION: {
+	case SYSID_SM_SYSTEM_VERSION:
+	case SYSID_SM_BASEBOARD_VERSION: {
 		ret = get_skuconfig(dev);
 
 		if (ret < 0)
@@ -162,7 +162,7 @@
 		sprintf(val, "rev%d", ret);
 		break;
 	}
-	case SYSINFO_ID_BOARD_MODEL: {
+	case SYSID_BOARD_MODEL: {
 		int mem_config, sku_config;
 		const char *model;
 
diff --git a/board/toradex/common/tdx-common.c b/board/toradex/common/tdx-common.c
index a6b45cd..3badeeb 100644
--- a/board/toradex/common/tdx-common.c
+++ b/board/toradex/common/tdx-common.c
@@ -193,7 +193,7 @@
 	int ret = -ENOTSUPP;
 
 	switch (id) {
-	case SYSINFO_ID_BOARD_MODEL:
+	case SYSID_BOARD_MODEL:
 		snprintf(val, size,
 			 "Toradex %04d %s %s",
 			 tdx_hw_tag.prodid,
diff --git a/cmd/bdinfo.c b/cmd/bdinfo.c
index 4c0e2ad..ae9e192 100644
--- a/cmd/bdinfo.c
+++ b/cmd/bdinfo.c
@@ -140,10 +140,6 @@
 #endif
 	bdinfo_print_num_l("boot_params", (ulong)bd->bi_boot_params);
 	print_bi_dram(bd);
-	if (IS_ENABLED(CONFIG_SYS_HAS_SRAM)) {
-		bdinfo_print_num_l("sramstart", (ulong)bd->bi_sramstart);
-		bdinfo_print_num_l("sramsize", (ulong)bd->bi_sramsize);
-	}
 	bdinfo_print_num_l("flashstart", (ulong)bd->bi_flashstart);
 	bdinfo_print_num_l("flashsize", (ulong)bd->bi_flashsize);
 	bdinfo_print_num_l("flashoffset", (ulong)bd->bi_flashoffset);
diff --git a/common/board_f.c b/common/board_f.c
index 98dc259..ebc934ab 100644
--- a/common/board_f.c
+++ b/common/board_f.c
@@ -637,13 +637,6 @@
 
 int setup_bdinfo(void)
 {
-	struct bd_info *bd = gd->bd;
-
-	if (IS_ENABLED(CONFIG_SYS_HAS_SRAM)) {
-		bd->bi_sramstart = CONFIG_SYS_SRAM_BASE; /* start of SRAM */
-		bd->bi_sramsize = CONFIG_SYS_SRAM_SIZE;  /* size  of SRAM */
-	}
-
 	return arch_setup_bdinfo();
 }
 
diff --git a/common/board_info.c b/common/board_info.c
index 33c260b..dc26e1a 100644
--- a/common/board_info.c
+++ b/common/board_info.c
@@ -18,9 +18,9 @@
 	const char *name;
 	enum sysinfo_id id;
 } to_show[] = {
-	{ "Manufacturer", SYSINFO_ID_BOARD_MANUFACTURER},
-	{ "Prior-stage version", SYSINFO_ID_PRIOR_STAGE_VERSION },
-	{ "Prior-stage date", SYSINFO_ID_PRIOR_STAGE_DATE },
+	{ "Manufacturer", SYSID_BOARD_MANUFACTURER},
+	{ "Prior-stage version", SYSID_PRIOR_STAGE_VERSION },
+	{ "Prior-stage date", SYSID_PRIOR_STAGE_DATE },
 	{ /* sentinel */ }
 };
 
@@ -39,7 +39,7 @@
 	if (ret)
 		return ret;
 
-	ret = sysinfo_get_str(dev, SYSINFO_ID_BOARD_MODEL, sizeof(str), str);
+	ret = sysinfo_get_str(dev, SYSID_BOARD_MODEL, sizeof(str), str);
 	if (ret)
 		return ret;
 	printf("Model: %s\n", str);
diff --git a/common/console.c b/common/console.c
index 2222470..863ac6a 100644
--- a/common/console.c
+++ b/common/console.c
@@ -745,11 +745,7 @@
 	}
 
 	if (IS_ENABLED(CONFIG_DEBUG_UART) && !(gd->flags & GD_FLG_SERIAL_READY)) {
-		while (*s) {
-			int ch = *s++;
-
-			printch(ch);
-		}
+		printascii(s);
 		return;
 	}
 
diff --git a/drivers/bios_emulator/biosemui.h b/drivers/bios_emulator/biosemui.h
index 954cd88..739a17c 100644
--- a/drivers/bios_emulator/biosemui.h
+++ b/drivers/bios_emulator/biosemui.h
@@ -128,6 +128,7 @@
 	u32 finalVal;
 } BE_portInfo;
 
+#if defined(X86EMU_RAW_IO)
 #define PM_inpb(port)	inb(port)
 #define PM_inpw(port)	inw(port)
 #define PM_inpd(port)	inl(port)
@@ -135,6 +136,46 @@
 #define PM_outpw(port, val)	outw(val, port)
 #define PM_outpd(port, val)	outl(val, port)
 
+#else
+
+/*
+ * Until the emulator code is fixed, at least print warnings.
+ */
+
+static inline u8 PM_inpb(u16 port)
+{
+	printf("x86 port 0x%x read attempt, returning 0\n", port);
+	return 0;
+}
+
+static inline u16 PM_inpw(u16 port)
+{
+	printf("x86 port 0x%x read attempt, returning 0\n", port);
+	return 0;
+}
+
+static inline u32 PM_inpd(u16 port)
+{
+	printf("x86 port 0x%x read attempt, returning 0\n", port);
+	return 0;
+}
+
+static inline void PM_outpb(u16 port, u8 val)
+{
+	printf("x86 port 0x%x write attempt, ignoring\n", port);
+}
+
+static inline void PM_outpw(u16 port, u16 val)
+{
+	printf("x86 port 0x%x write attempt, ignoring\n", port);
+}
+
+static inline void PM_outpd(u16 port, u32 val)
+{
+	printf("x86 port 0x%x write attempt, ignoring\n", port);
+}
+#endif
+
 #define LOG_inpb(port)	PM_inpb(port)
 #define LOG_inpw(port)	PM_inpw(port)
 #define LOG_inpd(port)	PM_inpd(port)
diff --git a/drivers/bios_emulator/x86emu/debug.c b/drivers/bios_emulator/x86emu/debug.c
index b426dc3..c63cf3d 100644
--- a/drivers/bios_emulator/x86emu/debug.c
+++ b/drivers/bios_emulator/x86emu/debug.c
@@ -38,6 +38,8 @@
 ****************************************************************************/
 
 #include <stdarg.h>
+#include <string.h>
+#include <vsprintf.h>
 #include <linux/ctype.h>
 #include <linux/printk.h>
 #include "x86emu/x86emui.h"
diff --git a/drivers/button/Kconfig b/drivers/button/Kconfig
index 3918b05..6cae16f 100644
--- a/drivers/button/Kconfig
+++ b/drivers/button/Kconfig
@@ -9,6 +9,17 @@
 	  can provide access to board-specific buttons. Use of the device tree
 	  for configuration is encouraged.
 
+config BUTTON_REMAP_PHONE_KEYS
+	bool "Remap phone keys for navigation"
+	depends on BUTTON
+	help
+	  Enable remapping of phone keys to navigation keys. This is useful for
+	  devices with phone keys that are not used in U-Boot. The phone keys
+	  are remapped to the following navigation keys:
+	  - Volume up: Up
+	  - Volume down: Down
+	  - Power: Enter
+
 config BUTTON_ADC
 	bool "Button adc"
 	depends on BUTTON
diff --git a/drivers/button/button-uclass.c b/drivers/button/button-uclass.c
index cda2433..729983d 100644
--- a/drivers/button/button-uclass.c
+++ b/drivers/button/button-uclass.c
@@ -10,6 +10,7 @@
 #include <button.h>
 #include <dm.h>
 #include <dm/uclass-internal.h>
+#include <dt-bindings/input/linux-event-codes.h>
 
 int button_get_by_label(const char *label, struct udevice **devp)
 {
@@ -37,14 +38,33 @@
 	return ops->get_state(dev);
 }
 
+static int button_remap_phone_keys(int code)
+{
+	switch (code) {
+	case KEY_VOLUMEUP:
+		return KEY_UP;
+	case KEY_VOLUMEDOWN:
+		return KEY_DOWN;
+	case KEY_POWER:
+		return KEY_ENTER;
+	default:
+		return code;
+	}
+}
+
 int button_get_code(struct udevice *dev)
 {
 	struct button_ops *ops = button_get_ops(dev);
+	int code;
 
 	if (!ops->get_code)
 		return -ENOSYS;
 
-	return ops->get_code(dev);
+	code = ops->get_code(dev);
+	if (CONFIG_IS_ENABLED(BUTTON_REMAP_PHONE_KEYS))
+		return button_remap_phone_keys(code);
+	else
+		return code;
 }
 
 UCLASS_DRIVER(button) = {
diff --git a/drivers/sysinfo/gazerbeam.h b/drivers/sysinfo/gazerbeam.h
index 6bf3c00..047f365 100644
--- a/drivers/sysinfo/gazerbeam.h
+++ b/drivers/sysinfo/gazerbeam.h
@@ -8,8 +8,8 @@
 #include <sysinfo.h>
 
 enum {
-	BOARD_HWVERSION = SYSINFO_ID_BOARD_MODEL,
-	BOARD_MULTICHANNEL = SYSINFO_ID_USER,
+	BOARD_HWVERSION = SYSID_BOARD_MODEL,
+	BOARD_MULTICHANNEL = SYSID_USER,
 	BOARD_VARIANT
 };
 
diff --git a/drivers/sysinfo/gpio.c b/drivers/sysinfo/gpio.c
index aaca318..66d2a91 100644
--- a/drivers/sysinfo/gpio.c
+++ b/drivers/sysinfo/gpio.c
@@ -38,7 +38,7 @@
 	struct sysinfo_gpio_priv *priv = dev_get_priv(dev);
 
 	switch (id) {
-	case SYSINFO_ID_BOARD_MODEL:
+	case SYSID_BOARD_MODEL:
 		*val = priv->revision;
 		return 0;
 	default:
@@ -51,7 +51,7 @@
 	struct sysinfo_gpio_priv *priv = dev_get_priv(dev);
 
 	switch (id) {
-	case SYSINFO_ID_BOARD_MODEL: {
+	case SYSID_BOARD_MODEL: {
 		const char *name = NULL;
 		int i, ret;
 		u32 revision;
diff --git a/drivers/sysinfo/rcar3.c b/drivers/sysinfo/rcar3.c
index 37e2ccc..2994df9 100644
--- a/drivers/sysinfo/rcar3.c
+++ b/drivers/sysinfo/rcar3.c
@@ -46,7 +46,7 @@
 	struct sysinfo_rcar_priv *priv = dev_get_priv(dev);
 
 	switch (id) {
-	case SYSINFO_ID_BOARD_MODEL:
+	case SYSID_BOARD_MODEL:
 		strncpy(val, priv->boardmodel, size);
 		val[size - 1] = '\0';
 		return 0;
diff --git a/drivers/sysinfo/sandbox.h b/drivers/sysinfo/sandbox.h
index d9c5804..a7cbac0 100644
--- a/drivers/sysinfo/sandbox.h
+++ b/drivers/sysinfo/sandbox.h
@@ -5,7 +5,7 @@
  */
 
 enum {
-	BOOL_CALLED_DETECT = SYSINFO_ID_USER,
+	BOOL_CALLED_DETECT = SYSID_USER,
 	INT_TEST1,
 	INT_TEST2,
 	STR_VACATIONSPOT,
diff --git a/include/asm-generic/u-boot.h b/include/asm-generic/u-boot.h
index 70303ac..8c619c1 100644
--- a/include/asm-generic/u-boot.h
+++ b/include/asm-generic/u-boot.h
@@ -30,8 +30,6 @@
 	unsigned long	bi_flashstart;	/* start of FLASH memory */
 	unsigned long	bi_flashsize;	/* size	 of FLASH memory */
 	unsigned long	bi_flashoffset; /* reserved area for startup monitor */
-	unsigned long	bi_sramstart;	/* start of SRAM memory */
-	unsigned long	bi_sramsize;	/* size	 of SRAM memory */
 #ifdef CONFIG_ARM
 	unsigned long	bi_arm_freq; /* arm frequency */
 	unsigned long	bi_dsp_freq; /* dsp core frequency */
diff --git a/include/configs/pic32mzdask.h b/include/configs/pic32mzdask.h
index 0ae4fc5..8de930e 100644
--- a/include/configs/pic32mzdask.h
+++ b/include/configs/pic32mzdask.h
@@ -19,8 +19,11 @@
  */
 /* Initial RAM for temporary stack, global data */
 #define CFG_SYS_INIT_RAM_SIZE	0x10000
+#define CFG_SYS_SRAM_BASE	0x80000000
+#define CFG_SYS_SRAM_SIZE	0x00080000
+
 #define CFG_SYS_INIT_RAM_ADDR	\
-	(CONFIG_SYS_SRAM_BASE + CONFIG_SYS_SRAM_SIZE - CFG_SYS_INIT_RAM_SIZE)
+	(CFG_SYS_SRAM_BASE + CFG_SYS_SRAM_SIZE - CFG_SYS_INIT_RAM_SIZE)
 
 /* SDRAM Configuration (for final code, data, stack, heap) */
 #define CFG_SYS_SDRAM_BASE		0x88000000
diff --git a/include/sysinfo.h b/include/sysinfo.h
index 8a77ef4..027a463 100644
--- a/include/sysinfo.h
+++ b/include/sysinfo.h
@@ -40,29 +40,29 @@
 
 /** enum sysinfo_id - Standard IDs defined by U-Boot */
 enum sysinfo_id {
-	SYSINFO_ID_NONE,
+	SYSID_NONE,
 
 	/* For SMBIOS tables */
-	SYSINFO_ID_SMBIOS_SYSTEM_MANUFACTURER,
-	SYSINFO_ID_SMBIOS_SYSTEM_PRODUCT,
-	SYSINFO_ID_SMBIOS_SYSTEM_VERSION,
-	SYSINFO_ID_SMBIOS_SYSTEM_SERIAL,
-	SYSINFO_ID_SMBIOS_SYSTEM_SKU,
-	SYSINFO_ID_SMBIOS_SYSTEM_FAMILY,
-	SYSINFO_ID_SMBIOS_BASEBOARD_MANUFACTURER,
-	SYSINFO_ID_SMBIOS_BASEBOARD_PRODUCT,
-	SYSINFO_ID_SMBIOS_BASEBOARD_VERSION,
-	SYSINFO_ID_SMBIOS_BASEBOARD_SERIAL,
-	SYSINFO_ID_SMBIOS_BASEBOARD_ASSET_TAG,
+	SYSID_SM_SYSTEM_MANUFACTURER,
+	SYSID_SM_SYSTEM_PRODUCT,
+	SYSID_SM_SYSTEM_VERSION,
+	SYSID_SM_SYSTEM_SERIAL,
+	SYSID_SM_SYSTEM_SKU,
+	SYSID_SM_SYSTEM_FAMILY,
+	SYSID_SM_BASEBOARD_MANUFACTURER,
+	SYSID_SM_BASEBOARD_PRODUCT,
+	SYSID_SM_BASEBOARD_VERSION,
+	SYSID_SM_BASEBOARD_SERIAL,
+	SYSID_SM_BASEBOARD_ASSET_TAG,
 
 	/* For show_board_info() */
-	SYSINFO_ID_BOARD_MODEL,
-	SYSINFO_ID_BOARD_MANUFACTURER,
-	SYSINFO_ID_PRIOR_STAGE_VERSION,
-	SYSINFO_ID_PRIOR_STAGE_DATE,
+	SYSID_BOARD_MODEL,
+	SYSID_BOARD_MANUFACTURER,
+	SYSID_PRIOR_STAGE_VERSION,
+	SYSID_PRIOR_STAGE_DATE,
 
 	/* First value available for downstream/board used */
-	SYSINFO_ID_USER = 0x1000,
+	SYSID_USER = 0x1000,
 };
 
 struct sysinfo_ops {
diff --git a/lib/smbios.c b/lib/smbios.c
index 7c24ea1..a36d4b4 100644
--- a/lib/smbios.c
+++ b/lib/smbios.c
@@ -270,7 +270,7 @@
 static int smbios_add_prop(struct smbios_ctx *ctx, const char *prop,
 			   const char *dval)
 {
-	return smbios_add_prop_si(ctx, prop, SYSINFO_ID_NONE, dval);
+	return smbios_add_prop_si(ctx, prop, SYSID_NONE, dval);
 }
 
 static void smbios_set_eos(struct smbios_ctx *ctx, char *eos)
@@ -393,27 +393,27 @@
 	fill_smbios_header(t, SMBIOS_SYSTEM_INFORMATION, len, handle);
 	smbios_set_eos(ctx, t->eos);
 	t->manufacturer = smbios_add_prop_si(ctx, "manufacturer",
-					     SYSINFO_ID_SMBIOS_SYSTEM_MANUFACTURER,
+					     SYSID_SM_SYSTEM_MANUFACTURER,
 					     NULL);
 	t->product_name = smbios_add_prop_si(ctx, "product",
-					     SYSINFO_ID_SMBIOS_SYSTEM_PRODUCT,
+					     SYSID_SM_SYSTEM_PRODUCT,
 					     NULL);
 	t->version = smbios_add_prop_si(ctx, "version",
-					SYSINFO_ID_SMBIOS_SYSTEM_VERSION,
+					SYSID_SM_SYSTEM_VERSION,
 					NULL);
 	if (serial_str) {
 		t->serial_number = smbios_add_prop(ctx, NULL, serial_str);
 		strncpy((char *)t->uuid, serial_str, sizeof(t->uuid));
 	} else {
 		t->serial_number = smbios_add_prop_si(ctx, "serial",
-						      SYSINFO_ID_SMBIOS_SYSTEM_SERIAL,
+						      SYSID_SM_SYSTEM_SERIAL,
 						      NULL);
 	}
 	t->wakeup_type = SMBIOS_WAKEUP_TYPE_UNKNOWN;
 	t->sku_number = smbios_add_prop_si(ctx, "sku",
-					   SYSINFO_ID_SMBIOS_SYSTEM_SKU, NULL);
+					   SYSID_SM_SYSTEM_SKU, NULL);
 	t->family = smbios_add_prop_si(ctx, "family",
-				       SYSINFO_ID_SMBIOS_SYSTEM_FAMILY, NULL);
+				       SYSID_SM_SYSTEM_FAMILY, NULL);
 
 	len = t->length + smbios_string_table_len(ctx);
 	*current += len;
@@ -433,20 +433,20 @@
 	fill_smbios_header(t, SMBIOS_BOARD_INFORMATION, len, handle);
 	smbios_set_eos(ctx, t->eos);
 	t->manufacturer = smbios_add_prop_si(ctx, "manufacturer",
-					     SYSINFO_ID_SMBIOS_BASEBOARD_MANUFACTURER,
+					     SYSID_SM_BASEBOARD_MANUFACTURER,
 					     NULL);
 	t->product_name = smbios_add_prop_si(ctx, "product",
-					     SYSINFO_ID_SMBIOS_BASEBOARD_PRODUCT,
+					     SYSID_SM_BASEBOARD_PRODUCT,
 					     NULL);
 	t->version = smbios_add_prop_si(ctx, "version",
-					SYSINFO_ID_SMBIOS_BASEBOARD_VERSION,
+					SYSID_SM_BASEBOARD_VERSION,
 					NULL);
 
 	t->serial_number = smbios_add_prop_si(ctx, "serial",
-					      SYSINFO_ID_SMBIOS_BASEBOARD_SERIAL,
+					      SYSID_SM_BASEBOARD_SERIAL,
 					      NULL);
 	t->asset_tag_number = smbios_add_prop_si(ctx, "asset-tag",
-						 SYSINFO_ID_SMBIOS_BASEBOARD_ASSET_TAG,
+						 SYSID_SM_BASEBOARD_ASSET_TAG,
 						 NULL);
 	t->feature_flags = SMBIOS_BOARD_FEATURE_HOSTING;
 	t->board_type = SMBIOS_BOARD_MOTHERBOARD;
diff --git a/test/bootm.c b/test/bootm.c
index 52b83f1..9455f44 100644
--- a/test/bootm.c
+++ b/test/bootm.c
@@ -28,6 +28,7 @@
 
 	/* This tests relies on GD_FLG_SILENT not being set */
 	gd->flags &= ~GD_FLG_SILENT;
+	env_set("silent_linux", NULL);
 
 	*buf = '\0';
 	ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_ALL));
@@ -183,6 +184,7 @@
 	ut_asserteq(0, bootm_process_cmdline(buf, 22, BOOTM_CL_SUBST));
 
 	/* Check multiple substitutions */
+	ut_assertok(env_set("bvar", NULL));
 	ut_assertok(env_set("var", "abc"));
 	strcpy(buf, "some${var}thing${bvar}else");
 	ut_asserteq(0, bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SUBST));
@@ -201,6 +203,7 @@
 /* Test silent processing in the bootargs variable */
 static int bootm_test_silent_var(struct unit_test_state *uts)
 {
+	ut_assertok(env_set("var", NULL));
 	env_set("bootargs", NULL);
 	ut_assertok(bootm_process_cmdline_env(BOOTM_CL_SUBST));
 	ut_assertnull(env_get("bootargs"));
diff --git a/test/dm/sysinfo-gpio.c b/test/dm/sysinfo-gpio.c
index 155da3b..de9483c 100644
--- a/test/dm/sysinfo-gpio.c
+++ b/test/dm/sysinfo-gpio.c
@@ -29,9 +29,9 @@
 	sandbox_gpio_set_flags(gpio, 16, GPIOD_EXT_PULL_DOWN);
 	sandbox_gpio_set_flags(gpio, 17, 0);
 	ut_assertok(sysinfo_detect(sysinfo));
-	ut_assertok(sysinfo_get_int(sysinfo, SYSINFO_ID_BOARD_MODEL, &val));
+	ut_assertok(sysinfo_get_int(sysinfo, SYSID_BOARD_MODEL, &val));
 	ut_asserteq(19, val);
-	ut_assertok(sysinfo_get_str(sysinfo, SYSINFO_ID_BOARD_MODEL, sizeof(buf),
+	ut_assertok(sysinfo_get_str(sysinfo, SYSID_BOARD_MODEL, sizeof(buf),
 				    buf));
 	ut_asserteq_str("rev_a", buf);
 
@@ -43,9 +43,9 @@
 	sandbox_gpio_set_flags(gpio, 16, GPIOD_EXT_PULL_UP);
 	sandbox_gpio_set_flags(gpio, 17, GPIOD_EXT_PULL_DOWN);
 	ut_assertok(sysinfo_detect(sysinfo));
-	ut_assertok(sysinfo_get_int(sysinfo, SYSINFO_ID_BOARD_MODEL, &val));
+	ut_assertok(sysinfo_get_int(sysinfo, SYSID_BOARD_MODEL, &val));
 	ut_asserteq(5, val);
-	ut_assertok(sysinfo_get_str(sysinfo, SYSINFO_ID_BOARD_MODEL, sizeof(buf),
+	ut_assertok(sysinfo_get_str(sysinfo, SYSID_BOARD_MODEL, sizeof(buf),
 				    buf));
 	ut_asserteq_str("foo", buf);
 
@@ -57,9 +57,9 @@
 	sandbox_gpio_set_flags(gpio, 16, 0);
 	sandbox_gpio_set_flags(gpio, 17, GPIOD_EXT_PULL_UP);
 	ut_assertok(sysinfo_detect(sysinfo));
-	ut_assertok(sysinfo_get_int(sysinfo, SYSINFO_ID_BOARD_MODEL, &val));
+	ut_assertok(sysinfo_get_int(sysinfo, SYSID_BOARD_MODEL, &val));
 	ut_asserteq(15, val);
-	ut_assertok(sysinfo_get_str(sysinfo, SYSINFO_ID_BOARD_MODEL, sizeof(buf),
+	ut_assertok(sysinfo_get_str(sysinfo, SYSID_BOARD_MODEL, sizeof(buf),
 				    buf));
 	ut_asserteq_str("unknown", buf);
 
diff --git a/test/py/tests/test_mmc.py b/test/py/tests/test_mmc.py
index a96c4e8..4624043 100644
--- a/test/py/tests/test_mmc.py
+++ b/test/py/tests/test_mmc.py
@@ -18,16 +18,55 @@
 # Setup env__mmc_device_test_skip to not skipping the test. By default, its
 # value is set to True. Set it to False to run all tests for MMC device.
 env__mmc_device_test_skip = False
+
+# Setup env__mmc_device to set the supported mmc modes to be tested
+env__mmc_device {
+    'mmc_modes': ['MMC_LEGACY', 'SD_HS'],
+}
+
 """
 
 mmc_set_up = False
 controllers = 0
 devices = {}
+mmc_modes_name = []
+mmc_modes = []
+
+def setup_mmc_modes(cons):
+    global mmc_modes, mmc_modes_name
+    f = cons.config.env.get('env__mmc_device', None)
+    if f:
+        mmc_modes_name = f.get('mmc_modes', None)
+
+    # Set mmc mode to default mode (legacy), if speed mode config isn't enabled
+    if cons.config.buildconfig.get('config_mmc_speed_mode_set', 'n') != 'y':
+        mmc_modes = [0]
+        return
+
+    if mmc_modes_name:
+        mmc_help = cons.run_command('mmc -help')
+        m = re.search(r"\[MMC_LEGACY(.*\n.+])", mmc_help)
+        modes = [
+            x.strip()
+            for x in m.group()
+            .replace('\n', '')
+            .replace('[', '')
+            .replace(']', '')
+            .split(',')
+        ]
+
+        for mode in mmc_modes_name:
+            mmc_modes += [modes.index(mode)]
+    else:
+        # Set mmc mode to default mode (legacy), if it is not defined in env
+        mmc_modes = [0]
 
 def setup_mmc(u_boot_console):
     if u_boot_console.config.env.get('env__mmc_device_test_skip', True):
         pytest.skip('MMC device test is not enabled')
 
+    setup_mmc_modes(u_boot_console)
+
 @pytest.mark.buildconfigspec('cmd_mmc')
 def test_mmc_list(u_boot_console):
     setup_mmc(u_boot_console)
@@ -58,21 +97,22 @@
     fail = 0
     for x in range(0, controllers):
         devices[x]['detected'] = 'yes'
-        output = u_boot_console.run_command('mmc dev %d' % x)
 
-        # Some sort of switch here
-        if 'Card did not respond to voltage select' in output:
-            fail = 1
-            devices[x]['detected'] = 'no'
+        for y in mmc_modes:
+            output = u_boot_console.run_command('mmc dev %d 0 %d' % x, y)
 
-        if 'no mmc device at slot' in output:
-            devices[x]['detected'] = 'no'
+            if 'Card did not respond to voltage select' in output:
+                fail = 1
+                devices[x]['detected'] = 'no'
 
-        if 'MMC: no card present' in output:
-            devices[x]['detected'] = 'no'
+            if 'no mmc device at slot' in output:
+                devices[x]['detected'] = 'no'
 
-    if fail:
-        pytest.fail('Card not present')
+            if 'MMC: no card present' in output:
+                devices[x]['detected'] = 'no'
+
+        if fail:
+            pytest.fail('Card not present')
 
 @pytest.mark.buildconfigspec('cmd_mmc')
 def test_mmcinfo(u_boot_console):
@@ -81,19 +121,22 @@
 
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
-            output = u_boot_console.run_command('mmcinfo')
-            if 'busy timeout' in output:
-                pytest.skip('No SD/MMC/eMMC device present')
+            for y in mmc_modes:
+                u_boot_console.run_command('mmc dev %d 0 %d' % x, y)
+                output = u_boot_console.run_command('mmcinfo')
+                if 'busy timeout' in output:
+                    pytest.skip('No SD/MMC/eMMC device present')
 
-            obj = re.search(r'Capacity: (\d+|\d+[\.]?\d)', output)
-            try:
-                capacity = float(obj.groups()[0])
-                print(capacity)
-                devices[x]['capacity'] = capacity
-                print('Capacity of dev %d is: %g GiB' % (x, capacity))
-            except ValueError:
-                pytest.fail('MMC capacity not recognized')
+                assert mmc_modes_name[mmc_modes.index(y)] in output
+
+                obj = re.search(r'Capacity: (\d+|\d+[\.]?\d)', output)
+                try:
+                    capacity = float(obj.groups()[0])
+                    print(capacity)
+                    devices[x]['capacity'] = capacity
+                    print('Capacity of dev %d is: %g GiB' % (x, capacity))
+                except ValueError:
+                    pytest.fail('MMC capacity not recognized')
 
 @pytest.mark.buildconfigspec('cmd_mmc')
 def test_mmc_info(u_boot_console):
@@ -102,19 +145,21 @@
 
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
+            for y in mmc_modes:
+                u_boot_console.run_command('mmc dev %d 0 %d' % x, y)
 
-            output = u_boot_console.run_command('mmc info')
+                output = u_boot_console.run_command('mmc info')
+                assert mmc_modes_name[mmc_modes.index(y)] in output
 
-            obj = re.search(r'Capacity: (\d+|\d+[\.]?\d)', output)
-            try:
-                capacity = float(obj.groups()[0])
-                print(capacity)
-                if devices[x]['capacity'] != capacity:
-                    pytest.fail("MMC capacity doesn't match mmcinfo")
+                obj = re.search(r'Capacity: (\d+|\d+[\.]?\d)', output)
+                try:
+                    capacity = float(obj.groups()[0])
+                    print(capacity)
+                    if devices[x]['capacity'] != capacity:
+                        pytest.fail("MMC capacity doesn't match mmcinfo")
 
-            except ValueError:
-                pytest.fail('MMC capacity not recognized')
+                except ValueError:
+                    pytest.fail('MMC capacity not recognized')
 
 @pytest.mark.buildconfigspec('cmd_mmc')
 def test_mmc_rescan(u_boot_console):
@@ -126,12 +171,13 @@
 
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
-            output = u_boot_console.run_command('mmc rescan')
-            if output:
-                pytest.fail('mmc rescan has something to check')
-            output = u_boot_console.run_command('echo $?')
-            assert output.endswith('0')
+            for y in mmc_modes:
+                u_boot_console.run_command('mmc dev %d 0 %d' % x, y)
+                output = u_boot_console.run_command('mmc rescan')
+                if output:
+                    pytest.fail('mmc rescan has something to check')
+                output = u_boot_console.run_command('echo $?')
+                assert output.endswith('0')
 
 @pytest.mark.buildconfigspec('cmd_mmc')
 def test_mmc_part(u_boot_console):
@@ -148,7 +194,8 @@
 
             lines = output.split('\n')
             part_fat = []
-            part_ext = []
+            part_ext2 = []
+            part_ext4 = []
             for line in lines:
                 obj = re.search(
                         r'(\d)\s+\d+\s+\d+\s+\w+\d+\w+-\d+\s+(\d+\w+)', line)
@@ -161,15 +208,21 @@
                         print('Fat detected')
                         part_fat.append(part_id)
                     elif part_type == '83':
-                        print('ext detected')
-                        part_ext.append(part_id)
+                        print('ext(2/4) detected')
+                        output = u_boot_console.run_command(
+                            'fstype mmc %d:%d' % x, part_id
+                        )
+                        if 'ext2' in output:
+                            part_ext2.append(part_id)
+                        elif 'ext4' in output:
+                            part_ext4.append(part_id)
                     else:
                         pytest.fail('Unsupported Filesystem on device %d' % x)
-            devices[x]['ext4'] = part_ext
-            devices[x]['ext2'] = part_ext
+            devices[x]['ext4'] = part_ext4
+            devices[x]['ext2'] = part_ext2
             devices[x]['fat'] = part_fat
 
-            if not part_ext and not part_fat:
+            if not part_ext2 and not part_ext4 and not part_fat:
                 pytest.fail('No partition detected on device %d' % x)
 
 @pytest.mark.buildconfigspec('cmd_mmc')
@@ -185,7 +238,6 @@
     fs = 'fat'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -193,20 +245,22 @@
                 continue
 
             for part in partitions:
-                output = u_boot_console.run_command(
-                        'fatls mmc %d:%s' % (x, part))
-                if 'Unrecognized filesystem type' in output:
-                    partitions.remove(part)
-                    pytest.fail('Unrecognized filesystem')
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    output = u_boot_console.run_command(
+                            'fatls mmc %d:%s' % (x, part))
+                    if 'Unrecognized filesystem type' in output:
+                        partitions.remove(part)
+                        pytest.fail('Unrecognized filesystem')
 
-                if not re.search(r'\d file\(s\), \d dir\(s\)', output):
-                    pytest.fail('%s read failed on device %d' % (fs.upper, x))
-                output = u_boot_console.run_command(
-                        'fatinfo mmc %d:%s' % (x, part))
-                string = 'Filesystem: %s' % fs.upper
-                if re.search(string, output):
-                    pytest.fail('%s FS failed on device %d' % (fs.upper(), x))
-                part_detect = 1
+                    if not re.search(r'\d file\(s\), \d dir\(s\)', output):
+                        pytest.fail('%s read failed on device %d' % (fs.upper, x))
+                    output = u_boot_console.run_command(
+                            'fatinfo mmc %d:%s' % (x, part))
+                    string = 'Filesystem: %s' % fs.upper
+                    if re.search(string, output):
+                        pytest.fail('%s FS failed on device %d' % (fs.upper(), x))
+                    part_detect = 1
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
@@ -226,7 +280,6 @@
     fs = 'fat'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -234,49 +287,51 @@
                 continue
 
             for part in partitions:
-                part_detect = 1
-                addr = u_boot_utils.find_ram_base(u_boot_console)
-                devices[x]['addr_%d' % part] = addr
-                size = random.randint(4, 1 * 1024 * 1024)
-                devices[x]['size_%d' % part] = size
-                # count CRC32
-                output = u_boot_console.run_command('crc32 %x %x' % (addr, size))
-                m = re.search('==> (.+?)', output)
-                if not m:
-                    pytest.fail('CRC32 failed')
-                expected_crc32 = m.group(1)
-                devices[x]['expected_crc32_%d' % part] = expected_crc32
-                # do write
-                file = '%s_%d' % ('uboot_test', size)
-                devices[x]['file_%d' % part] = file
-                output = u_boot_console.run_command(
-                    '%swrite mmc %d:%s %x %s %x' % (fs, x, part, addr, file, size)
-                )
-                assert 'Unable to write' not in output
-                assert 'Error' not in output
-                assert 'overflow' not in output
-                expected_text = '%d bytes written' % size
-                assert expected_text in output
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    part_detect = 1
+                    addr = u_boot_utils.find_ram_base(u_boot_console)
+                    devices[x]['addr_%d' % part] = addr
+                    size = random.randint(4, 1 * 1024 * 1024)
+                    devices[x]['size_%d' % part] = size
+                    # count CRC32
+                    output = u_boot_console.run_command('crc32 %x %x' % (addr, size))
+                    m = re.search('==> (.+?)', output)
+                    if not m:
+                        pytest.fail('CRC32 failed')
+                    expected_crc32 = m.group(1)
+                    devices[x]['expected_crc32_%d' % part] = expected_crc32
+                    # do write
+                    file = '%s_%d' % ('uboot_test', size)
+                    devices[x]['file_%d' % part] = file
+                    output = u_boot_console.run_command(
+                        '%swrite mmc %d:%s %x %s %x' % (fs, x, part, addr, file, size)
+                    )
+                    assert 'Unable to write' not in output
+                    assert 'Error' not in output
+                    assert 'overflow' not in output
+                    expected_text = '%d bytes written' % size
+                    assert expected_text in output
 
-                alignment = int(
-                    u_boot_console.config.buildconfig.get(
-                        'config_sys_cacheline_size', 128
+                    alignment = int(
+                        u_boot_console.config.buildconfig.get(
+                            'config_sys_cacheline_size', 128
+                        )
+                    )
+                    offset = random.randrange(alignment, 1024, alignment)
+                    output = u_boot_console.run_command(
+                        '%sload mmc %d:%s %x %s' % (fs, x, part, addr + offset, file)
                     )
-                )
-                offset = random.randrange(alignment, 1024, alignment)
-                output = u_boot_console.run_command(
-                    '%sload mmc %d:%s %x %s' % (fs, x, part, addr + offset, file)
-                )
-                assert 'Invalid FAT entry' not in output
-                assert 'Unable to read file' not in output
-                assert 'Misaligned buffer address' not in output
-                expected_text = '%d bytes read' % size
-                assert expected_text in output
+                    assert 'Invalid FAT entry' not in output
+                    assert 'Unable to read file' not in output
+                    assert 'Misaligned buffer address' not in output
+                    expected_text = '%d bytes read' % size
+                    assert expected_text in output
 
-                output = u_boot_console.run_command(
-                    'crc32 %x $filesize' % (addr + offset)
-                )
-                assert expected_crc32 in output
+                    output = u_boot_console.run_command(
+                        'crc32 %x $filesize' % (addr + offset)
+                    )
+                    assert expected_crc32 in output
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
@@ -300,13 +355,16 @@
                 print('No %s table on this device' % fs.upper())
                 continue
 
-            u_boot_console.run_command('mmc dev %d' % x)
             for part in partitions:
-                output = u_boot_console.run_command('%sls mmc %d:%s' % (fs, x, part))
-                if 'Unrecognized filesystem type' in output:
-                    partitions.remove(part)
-                    pytest.fail('Unrecognized filesystem')
-                part_detect = 1
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    output = u_boot_console.run_command(
+                        '%sls mmc %d:%s' % (fs, x, part)
+                    )
+                    if 'Unrecognized filesystem type' in output:
+                        partitions.remove(part)
+                        pytest.fail('Unrecognized filesystem')
+                    part_detect = 1
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
@@ -326,7 +384,6 @@
     fs = 'ext4'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -334,42 +391,44 @@
                 continue
 
             for part in partitions:
-                part_detect = 1
-                addr = u_boot_utils.find_ram_base(u_boot_console)
-                devices[x]['addr_%d' % part] = addr
-                size = random.randint(4, 1 * 1024 * 1024)
-                devices[x]['size_%d' % part] = size
-                # count CRC32
-                output = u_boot_console.run_command('crc32 %x %x' % (addr, size))
-                m = re.search('==> (.+?)', output)
-                if not m:
-                    pytest.fail('CRC32 failed')
-                expected_crc32 = m.group(1)
-                devices[x]['expected_crc32_%d' % part] = expected_crc32
-                # do write
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    part_detect = 1
+                    addr = u_boot_utils.find_ram_base(u_boot_console)
+                    devices[x]['addr_%d' % part] = addr
+                    size = random.randint(4, 1 * 1024 * 1024)
+                    devices[x]['size_%d' % part] = size
+                    # count CRC32
+                    output = u_boot_console.run_command('crc32 %x %x' % (addr, size))
+                    m = re.search('==> (.+?)', output)
+                    if not m:
+                        pytest.fail('CRC32 failed')
+                    expected_crc32 = m.group(1)
+                    devices[x]['expected_crc32_%d' % part] = expected_crc32
 
-                file = '%s_%d' % ('uboot_test', size)
-                devices[x]['file_%d' % part] = file
-                output = u_boot_console.run_command(
-                    '%swrite mmc %d:%s %x /%s %x' % (fs, x, part, addr, file, size)
-                )
-                assert 'Unable to write' not in output
-                assert 'Error' not in output
-                assert 'overflow' not in output
-                expected_text = '%d bytes written' % size
-                assert expected_text in output
+                    # do write
+                    file = '%s_%d' % ('uboot_test', size)
+                    devices[x]['file_%d' % part] = file
+                    output = u_boot_console.run_command(
+                        '%swrite mmc %d:%s %x /%s %x' % (fs, x, part, addr, file, size)
+                    )
+                    assert 'Unable to write' not in output
+                    assert 'Error' not in output
+                    assert 'overflow' not in output
+                    expected_text = '%d bytes written' % size
+                    assert expected_text in output
 
-                offset = random.randrange(128, 1024, 128)
-                output = u_boot_console.run_command(
-                    '%sload mmc %d:%s %x /%s' % (fs, x, part, addr + offset, file)
-                )
-                expected_text = '%d bytes read' % size
-                assert expected_text in output
+                    offset = random.randrange(128, 1024, 128)
+                    output = u_boot_console.run_command(
+                        '%sload mmc %d:%s %x /%s' % (fs, x, part, addr + offset, file)
+                    )
+                    expected_text = '%d bytes read' % size
+                    assert expected_text in output
 
-                output = u_boot_console.run_command(
-                    'crc32 %x $filesize' % (addr + offset)
-                )
-                assert expected_crc32 in output
+                    output = u_boot_console.run_command(
+                        'crc32 %x $filesize' % (addr + offset)
+                    )
+                    assert expected_crc32 in output
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
@@ -387,7 +446,6 @@
     fs = 'ext2'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -395,12 +453,16 @@
                 continue
 
             for part in partitions:
-                part_detect = 1
-                output = u_boot_console.run_command('%sls mmc %d:%s' % (fs, x, part))
-                if 'Unrecognized filesystem type' in output:
-                    partitions.remove(part)
-                    pytest.fail('Unrecognized filesystem')
-                part_detect = 1
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    part_detect = 1
+                    output = u_boot_console.run_command(
+                        '%sls mmc %d:%s' % (fs, x, part)
+                    )
+                    if 'Unrecognized filesystem type' in output:
+                        partitions.remove(part)
+                        pytest.fail('Unrecognized filesystem')
+                    part_detect = 1
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
@@ -421,7 +483,6 @@
     fs = 'ext2'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -429,23 +490,25 @@
                 continue
 
             for part in partitions:
-                part_detect = 1
-                addr = devices[x]['addr_%d' % part]
-                size = devices[x]['size_%d' % part]
-                expected_crc32 = devices[x]['expected_crc32_%d' % part]
-                file = devices[x]['file_%d' % part]
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    part_detect = 1
+                    addr = devices[x]['addr_%d' % part]
+                    size = devices[x]['size_%d' % part]
+                    expected_crc32 = devices[x]['expected_crc32_%d' % part]
+                    file = devices[x]['file_%d' % part]
 
-                offset = random.randrange(128, 1024, 128)
-                output = u_boot_console.run_command(
-                    '%sload mmc %d:%s %x /%s' % (fs, x, part, addr + offset, file)
-                )
-                expected_text = '%d bytes read' % size
-                assert expected_text in output
+                    offset = random.randrange(128, 1024, 128)
+                    output = u_boot_console.run_command(
+                        '%sload mmc %d:%s %x /%s' % (fs, x, part, addr + offset, file)
+                    )
+                    expected_text = '%d bytes read' % size
+                    assert expected_text in output
 
-                output = u_boot_console.run_command(
-                    'crc32 %x $filesize' % (addr + offset)
-                )
-                assert expected_crc32 in output
+                    output = u_boot_console.run_command(
+                        'crc32 %x $filesize' % (addr + offset)
+                    )
+                    assert expected_crc32 in output
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
@@ -462,8 +525,7 @@
     part_detect = 0
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
-            for fs in ['fat', 'ext4']:
+            for fs in ['fat', 'ext4', 'ext2']:
                 try:
                     partitions = devices[x][fs]
                 except:
@@ -471,12 +533,14 @@
                     continue
 
                 for part in partitions:
-                    part_detect = 1
-                    output = u_boot_console.run_command('ls mmc %d:%s' % (x, part))
-                    if re.search(r'No \w+ table on this device', output):
-                        pytest.fail(
-                            '%s: Partition table not found %d' % (fs.upper(), x)
-                        )
+                    for y in mmc_modes:
+                        u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                        part_detect = 1
+                        output = u_boot_console.run_command('ls mmc %d:%s' % (x, part))
+                        if re.search(r'No \w+ table on this device', output):
+                            pytest.fail(
+                                '%s: Partition table not found %d' % (fs.upper(), x)
+                            )
 
     if not part_detect:
         pytest.skip('No partition detected')
@@ -493,8 +557,7 @@
     part_detect = 0
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
-            for fs in ['fat', 'ext4']:
+            for fs in ['fat', 'ext4', 'ext2']:
                 try:
                     partitions = devices[x][fs]
                 except:
@@ -502,23 +565,25 @@
                     continue
 
                 for part in partitions:
-                    part_detect = 1
-                    addr = devices[x]['addr_%d' % part]
-                    size = devices[x]['size_%d' % part]
-                    expected_crc32 = devices[x]['expected_crc32_%d' % part]
-                    file = devices[x]['file_%d' % part]
+                    for y in mmc_modes:
+                        u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                        part_detect = 1
+                        addr = devices[x]['addr_%d' % part]
+                        size = devices[x]['size_%d' % part]
+                        expected_crc32 = devices[x]['expected_crc32_%d' % part]
+                        file = devices[x]['file_%d' % part]
 
-                    offset = random.randrange(128, 1024, 128)
-                    output = u_boot_console.run_command(
-                        'load mmc %d:%s %x /%s' % (x, part, addr + offset, file)
-                    )
-                    expected_text = '%d bytes read' % size
-                    assert expected_text in output
+                        offset = random.randrange(128, 1024, 128)
+                        output = u_boot_console.run_command(
+                            'load mmc %d:%s %x /%s' % (x, part, addr + offset, file)
+                        )
+                        expected_text = '%d bytes read' % size
+                        assert expected_text in output
 
-                    output = u_boot_console.run_command(
-                        'crc32 %x $filesize' % (addr + offset)
-                    )
-                    assert expected_crc32 in output
+                        output = u_boot_console.run_command(
+                            'crc32 %x $filesize' % (addr + offset)
+                        )
+                        assert expected_crc32 in output
 
     if not part_detect:
         pytest.skip('No partition detected')
@@ -535,8 +600,7 @@
     part_detect = 0
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
-            for fs in ['fat', 'ext4']:
+            for fs in ['fat', 'ext4', 'ext2']:
                 try:
                     partitions = devices[x][fs]
                 except:
@@ -544,18 +608,20 @@
                     continue
 
                 for part in partitions:
-                    part_detect = 1
-                    addr = devices[x]['addr_%d' % part]
-                    size = 0
-                    file = devices[x]['file_%d' % part]
+                    for y in mmc_modes:
+                        u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                        part_detect = 1
+                        addr = devices[x]['addr_%d' % part]
+                        size = 0
+                        file = devices[x]['file_%d' % part]
 
-                    offset = random.randrange(128, 1024, 128)
-                    output = u_boot_console.run_command(
-                        'save mmc %d:%s %x /%s %d'
-                        % (x, part, addr + offset, file, size)
-                    )
-                    expected_text = '%d bytes written' % size
-                    assert expected_text in output
+                        offset = random.randrange(128, 1024, 128)
+                        output = u_boot_console.run_command(
+                            'save mmc %d:%s %x /%s %d'
+                            % (x, part, addr + offset, file, size)
+                        )
+                        expected_text = '%d bytes written' % size
+                        assert expected_text in output
 
     if not part_detect:
         pytest.skip('No partition detected')
@@ -582,7 +648,6 @@
 
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -590,82 +655,86 @@
                 continue
 
             for part in partitions:
-                part_detect = 1
-                addr = u_boot_utils.find_ram_base(u_boot_console)
-                count_f = 0
-                addr_l = []
-                size_l = []
-                file_l = []
-                crc32_l = []
-                offset_l = []
-                addr_l.append(addr)
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    part_detect = 1
+                    addr = u_boot_utils.find_ram_base(u_boot_console)
+                    count_f = 0
+                    addr_l = []
+                    size_l = []
+                    file_l = []
+                    crc32_l = []
+                    offset_l = []
+                    addr_l.append(addr)
 
-                while count_f < num_files:
-                    size_l.append(random.randint(4, 1 * 1024 * 1024))
+                    while count_f < num_files:
+                        size_l.append(random.randint(4, 1 * 1024 * 1024))
 
-                    # CRC32 count
-                    output = u_boot_console.run_command(
-                        'crc32 %x %x' % (addr_l[count_f], size_l[count_f])
-                    )
-                    m = re.search('==> (.+?)', output)
-                    if not m:
-                        pytest.fail('CRC32 failed')
-                    crc32_l.append(m.group(1))
+                        # CRC32 count
+                        output = u_boot_console.run_command(
+                            'crc32 %x %x' % (addr_l[count_f], size_l[count_f])
+                        )
+                        m = re.search('==> (.+?)', output)
+                        if not m:
+                            pytest.fail('CRC32 failed')
+                        crc32_l.append(m.group(1))
 
-                    # Write operation
-                    file_l.append('%s_%d_%d' % ('uboot_test', count_f, size_l[count_f]))
-                    output = u_boot_console.run_command(
-                        '%swrite mmc %d:%s %x %s %x'
-                        % (
-                            fs,
-                            x,
-                            part,
-                            addr_l[count_f],
-                            file_l[count_f],
-                            size_l[count_f],
+                        # Write operation
+                        file_l.append(
+                            '%s_%d_%d' % ('uboot_test', count_f, size_l[count_f])
                         )
-                    )
-                    assert 'Unable to write' not in output
-                    assert 'Error' not in output
-                    assert 'overflow' not in output
-                    expected_text = '%d bytes written' % size_l[count_f]
-                    assert expected_text in output
+                        output = u_boot_console.run_command(
+                            '%swrite mmc %d:%s %x %s %x'
+                            % (
+                                fs,
+                                x,
+                                part,
+                                addr_l[count_f],
+                                file_l[count_f],
+                                size_l[count_f],
+                            )
+                        )
+                        assert 'Unable to write' not in output
+                        assert 'Error' not in output
+                        assert 'overflow' not in output
+                        expected_text = '%d bytes written' % size_l[count_f]
+                        assert expected_text in output
 
-                    addr_l.append(addr_l[count_f] + size_l[count_f] + 1048576)
-                    count_f += 1
+                        addr_l.append(addr_l[count_f] + size_l[count_f] + 1048576)
+                        count_f += 1
 
-                count_f = 0
-                while count_f < num_files:
-                    alignment = int(
-                        u_boot_console.config.buildconfig.get(
-                            'config_sys_cacheline_size', 128
+                    count_f = 0
+                    while count_f < num_files:
+                        alignment = int(
+                            u_boot_console.config.buildconfig.get(
+                                'config_sys_cacheline_size', 128
+                            )
                         )
-                    )
-                    offset_l.append(random.randrange(alignment, 1024, alignment))
+                        offset_l.append(random.randrange(alignment, 1024, alignment))
 
-                    # Read operation
-                    output = u_boot_console.run_command(
-                        '%sload mmc %d:%s %x %s'
-                        % (
-                            fs,
-                            x,
-                            part,
-                            addr_l[count_f] + offset_l[count_f],
-                            file_l[count_f],
+                        # Read operation
+                        output = u_boot_console.run_command(
+                            '%sload mmc %d:%s %x %s'
+                            % (
+                                fs,
+                                x,
+                                part,
+                                addr_l[count_f] + offset_l[count_f],
+                                file_l[count_f],
+                            )
                         )
-                    )
-                    assert 'Invalid FAT entry' not in output
-                    assert 'Unable to read file' not in output
-                    assert 'Misaligned buffer address' not in output
-                    expected_text = '%d bytes read' % size_l[count_f]
-                    assert expected_text in output
+                        assert 'Invalid FAT entry' not in output
+                        assert 'Unable to read file' not in output
+                        assert 'Misaligned buffer address' not in output
+                        expected_text = '%d bytes read' % size_l[count_f]
+                        assert expected_text in output
 
-                    output = u_boot_console.run_command(
-                        'crc32 %x $filesize' % (addr_l[count_f] + offset_l[count_f])
-                    )
-                    assert crc32_l[count_f] in output
+                        output = u_boot_console.run_command(
+                            'crc32 %x $filesize' % (addr_l[count_f] + offset_l[count_f])
+                        )
+                        assert crc32_l[count_f] in output
 
-                    count_f += 1
+                        count_f += 1
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
diff --git a/test/py/tests/test_usb.py b/test/py/tests/test_usb.py
index 2397fd3..e1f203b 100644
--- a/test/py/tests/test_usb.py
+++ b/test/py/tests/test_usb.py
@@ -227,7 +227,8 @@
 
             lines = output.split('\n')
             part_fat = []
-            part_ext = []
+            part_ext2 = []
+            part_ext4 = []
             for line in lines:
                 obj = re.search(r'(\d)\s+\d+\s+\d+\s+\w+\d+\w+-\d+\s+(\d+\w+)', line)
                 if obj:
@@ -239,15 +240,21 @@
                         print('Fat detected')
                         part_fat.append(part_id)
                     elif part_type == '83':
-                        print('ext detected')
-                        part_ext.append(part_id)
+                        print('ext(2/4) detected')
+                        output = u_boot_console.run_command(
+                            'fstype usb %d:%d' % i, part_id
+                        )
+                        if 'ext2' in output:
+                            part_ext2.append(part_id)
+                        elif 'ext4' in output:
+                            part_ext4.append(part_id)
                     else:
                         pytest.fail('Unsupported Filesystem on device %d' % i)
-            devices[i]['ext4'] = part_ext
-            devices[i]['ext2'] = part_ext
+            devices[i]['ext4'] = part_ext4
+            devices[i]['ext2'] = part_ext2
             devices[i]['fat'] = part_fat
 
-            if not part_ext and not part_fat:
+            if not part_ext2 and not part_ext4 and not part_fat:
                 pytest.fail('No partition detected on device %d' % i)
 
     return devices, controllers, storage_device
@@ -497,7 +504,7 @@
             for part in partitions:
                 part_detect = 1
                 file, size, expected_crc32 = \
-                    usb_ext4load_ext4write(u_boot_console, 'ext4', x, part)
+                    usb_ext4load_ext4write(u_boot_console, fs, x, part)
                 addr = u_boot_utils.find_ram_base(u_boot_console)
 
                 offset = random.randrange(128, 1024, 128)
@@ -526,7 +533,7 @@
     for x in range(0, int(storage_device)):
         if devices[x]['detected'] == 'yes':
             u_boot_console.run_command('usb dev %d' % x)
-            for fs in ['fat', 'ext4']:
+            for fs in ['fat', 'ext2', 'ext4']:
                 try:
                     partitions = devices[x][fs]
                 except:
@@ -556,7 +563,7 @@
     for x in range(0, int(storage_device)):
         if devices[x]['detected'] == 'yes':
             u_boot_console.run_command('usb dev %d' % x)
-            for fs in ['fat', 'ext4']:
+            for fs in ['fat', 'ext2', 'ext4']:
                 try:
                     partitions = devices[x][fs]
                 except:
@@ -570,7 +577,7 @@
                     if fs == 'fat':
                         file, size, expected_crc32 = \
                             usb_fatload_fatwrite(u_boot_console, fs, x, part)
-                    elif fs == 'ext4':
+                    elif fs in ['ext4', 'ext2']:
                         file, size, expected_crc32 = \
                             usb_ext4load_ext4write(u_boot_console, fs, x, part)
 
@@ -600,7 +607,7 @@
     for x in range(0, int(storage_device)):
         if devices[x]['detected'] == 'yes':
             u_boot_console.run_command('usb dev %d' % x)
-            for fs in ['fat', 'ext4']:
+            for fs in ['fat', 'ext2', 'ext4']:
                 try:
                     partitions = devices[x][fs]
                 except: