[people/ms/u-boot.git] / common / spl / spl_mmc.c

/*
 * (C) Copyright 2010
 * Texas Instruments, <www.ti.com>
 *
 * Aneesh V <aneesh@ti.com>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */
#include <common.h>
#include <dm.h>
#include <spl.h>
#include <linux/compiler.h>
#include <errno.h>
#include <asm/u-boot.h>
#include <errno.h>
#include <mmc.h>
#include <image.h>

DECLARE_GLOBAL_DATA_PTR;

static int mmc_load_legacy(struct mmc *mmc, ulong sector,
			   struct image_header *header)
{
	u32 image_size_sectors;
	unsigned long count;

	spl_parse_image_header(header);
	/* convert size to sectors - round up */
	image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) /
			     mmc->read_bl_len;

	/* Read the header too to avoid extra memcpy */
	count = mmc->block_dev.block_read(&mmc->block_dev, sector,
					  image_size_sectors,
					  (void *)(ulong)spl_image.load_addr);
	debug("read %x sectors to %x\n", image_size_sectors,
	      spl_image.load_addr);
	if (count != image_size_sectors)
		return -EIO;

	return 0;
}

static ulong h_spl_load_read(struct spl_load_info *load, ulong sector,
			     ulong count, void *buf)
{
	struct mmc *mmc = load->dev;

	return mmc->block_dev.block_read(&mmc->block_dev, sector, count, buf);
}

static int mmc_load_image_raw_sector(struct mmc *mmc, unsigned long sector)
{
	unsigned long count;
	struct image_header *header;
	int ret = 0;

	header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
					 sizeof(struct image_header));

	/* read image header to find the image size & load address */
	count = mmc->block_dev.block_read(&mmc->block_dev, sector, 1, header);
	debug("hdr read sector %lx, count=%lu\n", sector, count);
	if (count == 0) {
		ret = -EIO;
		goto end;
	}

	if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
	    image_get_magic(header) == FDT_MAGIC) {
		struct spl_load_info load;

		debug("Found FIT\n");
		load.dev = mmc;
		load.priv = NULL;
		load.bl_len = mmc->read_bl_len;
		load.read = h_spl_load_read;
		ret = spl_load_simple_fit(&load, sector, header);
	} else {
		ret = mmc_load_legacy(mmc, sector, header);
	}

end:
	if (ret) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		puts("spl: mmc block read error\n");
#endif
		return -1;
	}

	return 0;
}

int spl_mmc_get_device_index(u32 boot_device)
{
	switch (boot_device) {
	case BOOT_DEVICE_MMC1:
		return 0;
	case BOOT_DEVICE_MMC2:
	case BOOT_DEVICE_MMC2_2:
		return 1;
	}

#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	printf("spl: unsupported mmc boot device.\n");
#endif

	return -ENODEV;
}

static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device)
{
#ifdef CONFIG_DM_MMC
	struct udevice *dev;
#endif
	int err, mmc_dev;

	mmc_dev = spl_mmc_get_device_index(boot_device);
	if (mmc_dev < 0)
		return mmc_dev;

	err = mmc_initialize(NULL);
	if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		printf("spl: could not initialize mmc. error: %d\n", err);
#endif
		return err;
	}

#ifdef CONFIG_DM_MMC
	err = uclass_get_device(UCLASS_MMC, mmc_dev, &dev);
	if (!err)
		*mmcp = mmc_get_mmc_dev(dev);
#else
	*mmcp = find_mmc_device(mmc_dev);
	err = *mmcp ? 0 : -ENODEV;
#endif
	if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		printf("spl: could not find mmc device. error: %d\n", err);
#endif
		return err;
	}

	return 0;
}

#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION
static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
{
	disk_partition_t info;
	int err;

	err = part_get_info(&mmc->block_dev, partition, &info);
	if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		puts("spl: partition error\n");
#endif
		return -1;
	}

#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR
	return mmc_load_image_raw_sector(mmc, info.start +
					 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
#else
	return mmc_load_image_raw_sector(mmc, info.start);
#endif
}
#else
#define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION -1
static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
{
	return -ENOSYS;
}
#endif

#ifdef CONFIG_SPL_OS_BOOT
static int mmc_load_image_raw_os(struct mmc *mmc)
{
	unsigned long count;
	int ret;

	count = mmc->block_dev.block_read(&mmc->block_dev,
		CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
		CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
		(void *) CONFIG_SYS_SPL_ARGS_ADDR);
	if (count == 0) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		puts("spl: mmc block read error\n");
#endif
		return -1;
	}

	ret = mmc_load_image_raw_sector(mmc,
		CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR);
	if (ret)
		return ret;

	if (spl_image.os != IH_OS_LINUX) {
		puts("Expected Linux image is not found. Trying to start U-boot\n");
		return -ENOENT;
	}

	return 0;
}
#else
int spl_start_uboot(void)
{
	return 1;
}
static int mmc_load_image_raw_os(struct mmc *mmc)
{
	return -ENOSYS;
}
#endif

#ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
int spl_mmc_do_fs_boot(struct mmc *mmc)
{
	int err = -ENOSYS;

#ifdef CONFIG_SPL_FAT_SUPPORT
	if (!spl_start_uboot()) {
		err = spl_load_image_fat_os(&mmc->block_dev,
			CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
		if (!err)
			return err;
	}
#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
	err = spl_load_image_fat(&mmc->block_dev,
				 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
				 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
	if (!err)
		return err;
#endif
#endif
#ifdef CONFIG_SPL_EXT_SUPPORT
	if (!spl_start_uboot()) {
		err = spl_load_image_ext_os(&mmc->block_dev,
			CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
		if (!err)
			return err;
	}
#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
	err = spl_load_image_ext(&mmc->block_dev,
				 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
				 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
	if (!err)
		return err;
#endif
#endif

#if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT)
	err = -ENOENT;
#endif

	return err;
}
#else
int spl_mmc_do_fs_boot(struct mmc *mmc)
{
	return -ENOSYS;
}
#endif

int spl_mmc_load_image(u32 boot_device)
{
	struct mmc *mmc = NULL;
	u32 boot_mode;
	int err = 0;
	__maybe_unused int part;

	err = spl_mmc_find_device(&mmc, boot_device);
	if (err)
		return err;

	err = mmc_init(mmc);
	if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		printf("spl: mmc init failed with error: %d\n", err);
#endif
		return err;
	}

	boot_mode = spl_boot_mode();
	err = -EINVAL;
	switch (boot_mode) {
	case MMCSD_MODE_EMMCBOOT:
			/*
			 * We need to check what the partition is configured to.
			 * 1 and 2 match up to boot0 / boot1 and 7 is user data
			 * which is the first physical partition (0).
			 */
			part = (mmc->part_config >> 3) & PART_ACCESS_MASK;

			if (part == 7)
				part = 0;

			err = mmc_switch_part(0, part);
			if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
				puts("spl: mmc partition switch failed\n");
#endif
				return err;
			}
			/* Fall through */
	case MMCSD_MODE_RAW:
		debug("spl: mmc boot mode: raw\n");

		if (!spl_start_uboot()) {
			err = mmc_load_image_raw_os(mmc);
			if (!err)
				return err;
		}

		err = mmc_load_image_raw_partition(mmc,
			CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
		if (!err)
			return err;
#if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR)
		err = mmc_load_image_raw_sector(mmc,
			CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
		if (!err)
			return err;
#endif
		/* If RAW mode fails, try FS mode. */
	case MMCSD_MODE_FS:
		debug("spl: mmc boot mode: fs\n");

		err = spl_mmc_do_fs_boot(mmc);
		if (!err)
			return err;

		break;
	case MMCSD_MODE_UNDEFINED:
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	default:
		puts("spl: mmc: wrong boot mode\n");
#endif
	}

	return err;
}
Commit	Line	Data
9ea5c6ef SS	1	/*
	2	* (C) Copyright 2010
	3	* Texas Instruments, <www.ti.com>
	4	*
	5	* Aneesh V <aneesh@ti.com>
	6	*
1a459660	7	* SPDX-License-Identifier: GPL-2.0+
9ea5c6ef SS	8	*/
9ea5c6ef SS	9	#include <common.h>
dc3dedfe	10	#include <dm.h>
47f7bcae	11	#include <spl.h>
91199f4a	12	#include <linux/compiler.h>
36afd451	13	#include <errno.h>
9ea5c6ef	14	#include <asm/u-boot.h>
4188ba32	15	#include <errno.h>
9ea5c6ef	16	#include <mmc.h>
e4c444b3	17	#include <image.h>
9ea5c6ef SS	18
	19	DECLARE_GLOBAL_DATA_PTR;
	20
96debd1f SG	21	static int mmc_load_legacy(struct mmc *mmc, ulong sector,
	22	struct image_header *header)
	23	{
	24	u32 image_size_sectors;
	25	unsigned long count;
	26
	27	spl_parse_image_header(header);
	28	/* convert size to sectors - round up */
	29	image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) /
	30	mmc->read_bl_len;
	31
	32	/* Read the header too to avoid extra memcpy */
	33	count = mmc->block_dev.block_read(&mmc->block_dev, sector,
	34	image_size_sectors,
	35	(void *)(ulong)spl_image.load_addr);
	36	debug("read %x sectors to %x\n", image_size_sectors,
	37	spl_image.load_addr);
	38	if (count != image_size_sectors)
	39	return -EIO;
	40
	41	return 0;
	42	}
	43
96debd1f SG	44	static ulong h_spl_load_read(struct spl_load_info *load, ulong sector,
	45	ulong count, void *buf)
	46	{
	47	struct mmc *mmc = load->dev;
	48
	49	return mmc->block_dev.block_read(&mmc->block_dev, sector, count, buf);
	50	}
96debd1f	51
b97300b6	52	static int mmc_load_image_raw_sector(struct mmc *mmc, unsigned long sector)
9ea5c6ef	53	{
3bc37b6d	54	unsigned long count;
2e222105	55	struct image_header *header;
96debd1f	56	int ret = 0;
9ea5c6ef SS	57
9ea5c6ef SS	58	header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
91199f4a	59	sizeof(struct image_header));
9ea5c6ef SS	60
9ea5c6ef SS	61	/* read image header to find the image size & load address */
7c4213f6	62	count = mmc->block_dev.block_read(&mmc->block_dev, sector, 1, header);
96debd1f SG	63	debug("hdr read sector %lx, count=%lu\n", sector, count);
	64	if (count == 0) {
	65	ret = -EIO;
9ea5c6ef	66	goto end;
96debd1f	67	}
9ea5c6ef	68
4976f482 MY	69	if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
4976f482 MY	70	image_get_magic(header) == FDT_MAGIC) {
96debd1f SG	71	struct spl_load_info load;
	72
	73	debug("Found FIT\n");
	74	load.dev = mmc;
	75	load.priv = NULL;
	76	load.bl_len = mmc->read_bl_len;
	77	load.read = h_spl_load_read;
	78	ret = spl_load_simple_fit(&load, sector, header);
4976f482 MY	79	} else {
4976f482 MY	80	ret = mmc_load_legacy(mmc, sector, header);
fdfa39d3	81	}
e4c444b3	82
9ea5c6ef	83	end:
96debd1f	84	if (ret) {
8112f5fa	85	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
1ec26469	86	puts("spl: mmc block read error\n");
8112f5fa	87	#endif
3bc37b6d	88	return -1;
1ec26469	89	}
3bc37b6d PK	90
3bc37b6d PK	91	return 0;
9ea5c6ef SS	92	}
9ea5c6ef SS	93
a1e56cf6 NK	94	int spl_mmc_get_device_index(u32 boot_device)
	95	{
	96	switch (boot_device) {
	97	case BOOT_DEVICE_MMC1:
	98	return 0;
	99	case BOOT_DEVICE_MMC2:
	100	case BOOT_DEVICE_MMC2_2:
	101	return 1;
	102	}
	103
	104	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	105	printf("spl: unsupported mmc boot device.\n");
	106	#endif
	107
	108	return -ENODEV;
	109	}
	110
99c7a51a	111	static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device)
4188ba32	112	{
b4857aa9	113	#ifdef CONFIG_DM_MMC
4188ba32	114	struct udevice *dev;
b4857aa9	115	#endif
a1e56cf6 NK	116	int err, mmc_dev;
	117
	118	mmc_dev = spl_mmc_get_device_index(boot_device);
	119	if (mmc_dev < 0)
	120	return mmc_dev;
4188ba32 NK	121
	122	err = mmc_initialize(NULL);
	123	if (err) {
	124	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	125	printf("spl: could not initialize mmc. error: %d\n", err);
	126	#endif
	127	return err;
	128	}
	129
b4857aa9	130	#ifdef CONFIG_DM_MMC
a1e56cf6	131	err = uclass_get_device(UCLASS_MMC, mmc_dev, &dev);
b4857aa9 SG	132	if (!err)
b4857aa9 SG	133	*mmcp = mmc_get_mmc_dev(dev);
4188ba32	134	#else
b4857aa9 SG	135	*mmcp = find_mmc_device(mmc_dev);
	136	err = *mmcp ? 0 : -ENODEV;
	137	#endif
4188ba32 NK	138	if (err) {
4188ba32 NK	139	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
b4857aa9	140	printf("spl: could not find mmc device. error: %d\n", err);
4188ba32 NK	141	#endif
	142	return err;
	143	}
	144
4188ba32 NK	145	return 0;
4188ba32 NK	146	}
4188ba32	147
b97300b6 PK	148	#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION
	149	static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
	150	{
	151	disk_partition_t info;
3bc37b6d	152	int err;
b97300b6	153
3e8bd469	154	err = part_get_info(&mmc->block_dev, partition, &info);
3bc37b6d	155	if (err) {
b97300b6	156	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
1ec26469	157	puts("spl: partition error\n");
b97300b6 PK	158	#endif
	159	return -1;
	160	}
	161
4bfcc54c SR	162	#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR
	163	return mmc_load_image_raw_sector(mmc, info.start +
	164	CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
	165	#else
b97300b6	166	return mmc_load_image_raw_sector(mmc, info.start);
4bfcc54c	167	#endif
b97300b6	168	}
d074ebb9 NK	169	#else
	170	#define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION -1
	171	static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
	172	{
	173	return -ENOSYS;
	174	}
b97300b6 PK	175	#endif
b97300b6 PK	176
2b75b0ad PK	177	#ifdef CONFIG_SPL_OS_BOOT
	178	static int mmc_load_image_raw_os(struct mmc *mmc)
	179	{
3bc37b6d	180	unsigned long count;
811906ae	181	int ret;
91199f4a	182
7c4213f6	183	count = mmc->block_dev.block_read(&mmc->block_dev,
3bc37b6d PK	184	CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
	185	CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
	186	(void *) CONFIG_SYS_SPL_ARGS_ADDR);
	187	if (count == 0) {
8112f5fa	188	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
1ec26469	189	puts("spl: mmc block read error\n");
8112f5fa	190	#endif
2b75b0ad PK	191	return -1;
	192	}
	193
811906ae	194	ret = mmc_load_image_raw_sector(mmc,
91199f4a	195	CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR);
811906ae LV	196	if (ret)
	197	return ret;
	198
	199	if (spl_image.os != IH_OS_LINUX) {
	200	puts("Expected Linux image is not found. Trying to start U-boot\n");
	201	return -ENOENT;
	202	}
	203
	204	return 0;
2b75b0ad	205	}
339245b7 NK	206	#else
	207	int spl_start_uboot(void)
	208	{
	209	return 1;
	210	}
	211	static int mmc_load_image_raw_os(struct mmc *mmc)
	212	{
	213	return -ENOSYS;
	214	}
2b75b0ad PK	215	#endif
2b75b0ad PK	216
f52b7293 NK	217	#ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
	218	int spl_mmc_do_fs_boot(struct mmc *mmc)
	219	{
	220	int err = -ENOSYS;
	221
	222	#ifdef CONFIG_SPL_FAT_SUPPORT
	223	if (!spl_start_uboot()) {
	224	err = spl_load_image_fat_os(&mmc->block_dev,
	225	CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
	226	if (!err)
	227	return err;
	228	}
	229	#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
	230	err = spl_load_image_fat(&mmc->block_dev,
	231	CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
	232	CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
	233	if (!err)
	234	return err;
	235	#endif
	236	#endif
	237	#ifdef CONFIG_SPL_EXT_SUPPORT
	238	if (!spl_start_uboot()) {
	239	err = spl_load_image_ext_os(&mmc->block_dev,
	240	CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
	241	if (!err)
	242	return err;
	243	}
	244	#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
	245	err = spl_load_image_ext(&mmc->block_dev,
	246	CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
	247	CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
	248	if (!err)
	249	return err;
	250	#endif
	251	#endif
	252
	253	#if defined(CONFIG_SPL_FAT_SUPPORT) \|\| defined(CONFIG_SPL_EXT_SUPPORT)
	254	err = -ENOENT;
	255	#endif
	256
	257	return err;
	258	}
	259	#else
	260	int spl_mmc_do_fs_boot(struct mmc *mmc)
	261	{
	262	return -ENOSYS;
	263	}
	264	#endif
	265
a1e56cf6	266	int spl_mmc_load_image(u32 boot_device)
9ea5c6ef	267	{
d773a008	268	struct mmc *mmc = NULL;
9ea5c6ef	269	u32 boot_mode;
dc3dedfe	270	int err = 0;
91199f4a	271	__maybe_unused int part;
9ea5c6ef	272
a1e56cf6	273	err = spl_mmc_find_device(&mmc, boot_device);
36afd451 NK	274	if (err)
36afd451 NK	275	return err;
9ea5c6ef	276
4188ba32	277	err = mmc_init(mmc);
9ea5c6ef	278	if (err) {
8112f5fa	279	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
91199f4a	280	printf("spl: mmc init failed with error: %d\n", err);
8112f5fa	281	#endif
36afd451	282	return err;
9ea5c6ef	283	}
79adb7a2	284
37189a19	285	boot_mode = spl_boot_mode();
36afd451	286	err = -EINVAL;
91199f4a	287	switch (boot_mode) {
83cdf6fa NK	288	case MMCSD_MODE_EMMCBOOT:
	289	/*
	290	* We need to check what the partition is configured to.
	291	* 1 and 2 match up to boot0 / boot1 and 7 is user data
	292	* which is the first physical partition (0).
	293	*/
	294	part = (mmc->part_config >> 3) & PART_ACCESS_MASK;
	295
	296	if (part == 7)
	297	part = 0;
	298
36afd451 NK	299	err = mmc_switch_part(0, part);
36afd451 NK	300	if (err) {
83cdf6fa NK	301	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	302	puts("spl: mmc partition switch failed\n");
	303	#endif
36afd451	304	return err;
83cdf6fa NK	305	}
83cdf6fa NK	306	/* Fall through */
91199f4a PK	307	case MMCSD_MODE_RAW:
	308	debug("spl: mmc boot mode: raw\n");
	309
91199f4a PK	310	if (!spl_start_uboot()) {
	311	err = mmc_load_image_raw_os(mmc);
	312	if (!err)
36afd451	313	return err;
91199f4a	314	}
d074ebb9	315
b97300b6 PK	316	err = mmc_load_image_raw_partition(mmc,
b97300b6 PK	317	CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
3ae8f4c8	318	if (!err)
36afd451	319	return err;
d074ebb9	320	#if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR)
b97300b6	321	err = mmc_load_image_raw_sector(mmc,
773b5940	322	CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
91199f4a	323	if (!err)
36afd451	324	return err;
3ae8f4c8	325	#endif
86a0df73	326	/* If RAW mode fails, try FS mode. */
91199f4a PK	327	case MMCSD_MODE_FS:
	328	debug("spl: mmc boot mode: fs\n");
	329
f52b7293	330	err = spl_mmc_do_fs_boot(mmc);
91199f4a	331	if (!err)
36afd451	332	return err;
f52b7293	333
fd61d399	334	break;
91199f4a	335	case MMCSD_MODE_UNDEFINED:
8112f5fa	336	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
fd61d399 NK	337	default:
fd61d399 NK	338	puts("spl: mmc: wrong boot mode\n");
8112f5fa	339	#endif
91199f4a	340	}
fd61d399	341
36afd451	342	return err;
9ea5c6ef	343	}