X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=common%2Fspl%2Fspl_mmc.c;h=c27a2502511cd9c92b093672af48a6a24c2d757e;hb=d695d6627803;hp=5f1cfbf98e97daf107d0e07a649534534d153423;hpb=3c9cc70d7153da442575112d9a2643eecd17d534;p=people%2Fms%2Fu-boot.git

diff --git a/common/spl/spl_mmc.c b/common/spl/spl_mmc.c
index 5f1cfbf98e..351f4edd41 100644
--- a/common/spl/spl_mmc.c
+++ b/common/spl/spl_mmc.c
@@ -10,62 +10,170 @@
 #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_image_raw_sector(struct mmc *mmc, unsigned long sector)
+static int mmc_load_legacy(struct spl_image_info *spl_image, struct mmc *mmc,
+			   ulong sector, struct image_header *header)
 {
-	unsigned long count;
 	u32 image_size_sectors;
+	unsigned long count;
+	int ret;
+
+	ret = spl_parse_image_header(spl_image, header);
+	if (ret)
+		return ret;
+
+	/* 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 = blk_dread(mmc_get_blk_desc(mmc), sector, image_size_sectors,
+			  (void *)(ulong)spl_image->load_addr);
+	debug("read %x sectors to %lx\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 blk_dread(mmc_get_blk_desc(mmc), sector, count, buf);
+}
+
+static __maybe_unused
+int mmc_load_image_raw_sector(struct spl_image_info *spl_image,
+			      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(0, sector, 1, header);
-	debug("read sector %lx, count=%lu\n", sector, count);
-	if (count == 0)
+	count = blk_dread(mmc_get_blk_desc(mmc), sector, 1, header);
+	debug("hdr read sector %lx, count=%lu\n", sector, count);
+	if (count == 0) {
+		ret = -EIO;
 		goto end;
+	}
 
-	if (image_get_magic(header) != IH_MAGIC) {
-		puts("bad magic\n");
+	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.filename = NULL;
+		load.bl_len = mmc->read_bl_len;
+		load.read = h_spl_load_read;
+		ret = spl_load_simple_fit(spl_image, &load, sector, header);
+	} else {
+		ret = mmc_load_legacy(spl_image, mmc, sector, header);
+	}
+
+end:
+	if (ret) {
+#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
+		puts("mmc_load_image_raw_sector: mmc block read error\n");
+#endif
 		return -1;
 	}
 
-	spl_parse_image_header(header);
+	return 0;
+}
 
-	/* convert size to sectors - round up */
-	image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) /
-			     mmc->read_bl_len;
+static 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;
+	}
 
-	/* Read the header too to avoid extra memcpy */
-	count = mmc->block_dev.block_read(0, sector, image_size_sectors,
-					  (void *)spl_image.load_addr);
-	debug("read %x sectors to %x\n", image_size_sectors,
-	      spl_image.load_addr);
+#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
+	printf("spl: unsupported mmc boot device.\n");
+#endif
 
-end:
-	if (count == 0) {
+	return -ENODEV;
+}
+
+static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device)
+{
+#if CONFIG_IS_ENABLED(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
-		puts("spl: mmc block read error\n");
+		printf("spl: could not initialize mmc. error: %d\n", err);
 #endif
-		return -1;
+		return err;
+	}
+
+#if CONFIG_IS_ENABLED(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)
+#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION
+static int mmc_load_image_raw_partition(struct spl_image_info *spl_image,
+					struct mmc *mmc, int partition)
 {
 	disk_partition_t info;
 	int err;
 
-	err = get_partition_info(&mmc->block_dev, partition, &info);
+#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION_TYPE
+	int type_part;
+	/* Only support MBR so DOS_ENTRY_NUMBERS */
+	for (type_part = 1; type_part <= DOS_ENTRY_NUMBERS; type_part++) {
+		err = part_get_info(mmc_get_blk_desc(mmc), type_part, &info);
+		if (err)
+			continue;
+		if (info.sys_ind == 
+			CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION_TYPE) {
+			partition = type_part;
+			break;
+		}
+	}
+#endif
+
+	err = part_get_info(mmc_get_blk_desc(mmc), partition, &info);
 	if (err) {
 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
 		puts("spl: partition error\n");
@@ -73,177 +181,201 @@ static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
 		return -1;
 	}
 
-	return mmc_load_image_raw_sector(mmc, info.start);
+#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR
+	return mmc_load_image_raw_sector(spl_image, mmc,
+			info.start + CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
+#else
+	return mmc_load_image_raw_sector(spl_image, mmc, info.start);
+#endif
 }
 #endif
 
 #ifdef CONFIG_SPL_OS_BOOT
-static int mmc_load_image_raw_os(struct mmc *mmc)
+static int mmc_load_image_raw_os(struct spl_image_info *spl_image,
+				 struct mmc *mmc)
 {
 	unsigned long count;
+	int ret;
 
-	count = mmc->block_dev.block_read(0,
+	count = blk_dread(mmc_get_blk_desc(mmc),
 		CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
 		CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
 		(void *) CONFIG_SYS_SPL_ARGS_ADDR);
-	if (count == 0) {
+	if (count != CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS) {
 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
-		puts("spl: mmc block read error\n");
+		puts("mmc_load_image_raw_os: mmc block read error\n");
 #endif
 		return -1;
 	}
 
-	return mmc_load_image_raw_sector(mmc,
+	ret = mmc_load_image_raw_sector(spl_image, 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 spl_image_info *spl_image,
+				 struct mmc *mmc)
+{
+	return -ENOSYS;
 }
 #endif
 
-void spl_mmc_load_image(void)
+#ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
+static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc)
 {
-	struct mmc *mmc;
-	u32 boot_mode;
-	int err = 0;
-	__maybe_unused int part;
+	int err = -ENOSYS;
 
-#ifdef CONFIG_DM_MMC
-	struct udevice *dev;
-
-	mmc_initialize(NULL);
-	err = uclass_get_device(UCLASS_MMC, 0, &dev);
-	mmc = NULL;
+#ifdef CONFIG_SPL_FAT_SUPPORT
+	if (!spl_start_uboot()) {
+		err = spl_load_image_fat_os(spl_image, mmc_get_blk_desc(mmc),
+			CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
+		if (!err)
+			return err;
+	}
+#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
+	err = spl_load_image_fat(spl_image, mmc_get_blk_desc(mmc),
+				 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
+				 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
 	if (!err)
-		mmc = mmc_get_mmc_dev(dev);
-#else
-	mmc_initialize(gd->bd);
-
-	/* We register only one device. So, the dev id is always 0 */
-	mmc = find_mmc_device(0);
-	if (!mmc) {
-#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
-		puts("spl: mmc device not found\n");
+		return err;
+#endif
 #endif
-		hang();
+#ifdef CONFIG_SPL_EXT_SUPPORT
+	if (!spl_start_uboot()) {
+		err = spl_load_image_ext_os(spl_image, mmc_get_blk_desc(mmc),
+			CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
+		if (!err)
+			return err;
 	}
+#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
+	err = spl_load_image_ext(spl_image, mmc_get_blk_desc(mmc),
+				 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
+				 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
+	if (!err)
+		return err;
+#endif
 #endif
 
-	if (!err)
-		err = mmc_init(mmc);
+#if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT)
+	err = -ENOENT;
+#endif
+
+	return err;
+}
+#else
+static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc)
+{
+	return -ENOSYS;
+}
+#endif
+
+u32 __weak spl_boot_mode(const u32 boot_device)
+{
+#if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT)
+	return MMCSD_MODE_FS;
+#elif defined(CONFIG_SUPPORT_EMMC_BOOT)
+	return MMCSD_MODE_EMMCBOOT;
+#else
+	return MMCSD_MODE_RAW;
+#endif
+}
+
+int spl_mmc_load_image(struct spl_image_info *spl_image,
+		       struct spl_boot_device *bootdev)
+{
+	struct mmc *mmc = NULL;
+	u32 boot_mode;
+	int err = 0;
+	__maybe_unused int part;
 
+	err = spl_mmc_find_device(&mmc, bootdev->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
-		hang();
+		return err;
 	}
 
-	boot_mode = spl_boot_mode();
+	boot_mode = spl_boot_mode(bootdev->boot_device);
+	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;
+
+			if (CONFIG_IS_ENABLED(MMC_TINY))
+				err = mmc_switch_part(mmc, part);
+			else
+				err = blk_dselect_hwpart(mmc_get_blk_desc(mmc), 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");
 
-#ifdef CONFIG_SPL_OS_BOOT
 		if (!spl_start_uboot()) {
-			err = mmc_load_image_raw_os(mmc);
+			err = mmc_load_image_raw_os(spl_image, mmc);
 			if (!err)
-				return;
+				return err;
 		}
-#endif
-#if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION)
-		err = mmc_load_image_raw_partition(mmc,
+#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION
+		err = mmc_load_image_raw_partition(spl_image, mmc,
 			CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
 		if (!err)
-			return;
-#elif defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR)
-		err = mmc_load_image_raw_sector(mmc,
+			return err;
+#endif
+#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR
+		err = mmc_load_image_raw_sector(spl_image, mmc,
 			CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
 		if (!err)
-			return;
+			return err;
 #endif
+		/* If RAW mode fails, try FS mode. */
 	case MMCSD_MODE_FS:
 		debug("spl: mmc boot mode: fs\n");
 
-#ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
-#ifdef CONFIG_SPL_FAT_SUPPORT
-#ifdef CONFIG_SPL_OS_BOOT
-		if (!spl_start_uboot()) {
-			err = spl_load_image_fat_os(&mmc->block_dev,
-				CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
-			if (!err)
-				return;
-		}
-#endif
-#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;
-#endif
-#endif
-#ifdef CONFIG_SPL_EXT_SUPPORT
-#ifdef CONFIG_SPL_OS_BOOT
-		if (!spl_start_uboot()) {
-			err = spl_load_image_ext_os(&mmc->block_dev,
-				CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
-			if (!err)
-				return;
-		}
-#endif
-#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);
+		err = spl_mmc_do_fs_boot(spl_image, mmc);
 		if (!err)
-			return;
-#endif
-#endif
-#endif
-#ifdef CONFIG_SUPPORT_EMMC_BOOT
-	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;
+			return err;
 
-		if (part == 7)
-			part = 0;
-
-		if (mmc_switch_part(0, part)) {
+		break;
 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
-			puts("spl: mmc partition switch failed\n");
-#endif
-			hang();
-		}
-
-#ifdef CONFIG_SPL_OS_BOOT
-		if (!spl_start_uboot()) {
-			err = mmc_load_image_raw_os(mmc);
-			if (!err)
-				return;
-		}
-#endif
-#if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION)
-		err = mmc_load_image_raw_partition(mmc,
-			CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
-		if (!err)
-			return;
-#elif 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;
-#endif
-#endif
-	case MMCSD_MODE_UNDEFINED:
 	default:
-#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
-		if (err)
-			puts("spl: mmc: no boot mode left to try\n");
-		else
-			puts("spl: mmc: wrong boot mode\n");
+		puts("spl: mmc: wrong boot mode\n");
 #endif
-		hang();
 	}
+
+	return err;
 }
+
+SPL_LOAD_IMAGE_METHOD("MMC1", 0, BOOT_DEVICE_MMC1, spl_mmc_load_image);
+SPL_LOAD_IMAGE_METHOD("MMC2", 0, BOOT_DEVICE_MMC2, spl_mmc_load_image);
+SPL_LOAD_IMAGE_METHOD("MMC2_2", 0, BOOT_DEVICE_MMC2_2, spl_mmc_load_image);