blob: 7c7f32959b224a44b789bc8b4642c60b2e28655f [file] [log] [blame]
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -04001/*
2 * (C) Copyright 2010
3 * Texas Instruments, <www.ti.com>
4 *
5 * Aneesh V <aneesh@ti.com>
6 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02007 * SPDX-License-Identifier: GPL-2.0+
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -04008 */
9#include <common.h>
Simon Glassdc3dedf2015-06-23 15:38:51 -060010#include <dm.h>
Tom Rini47f7bca2012-08-13 12:03:19 -070011#include <spl.h>
Paul Kocialkowski91199f42015-04-27 10:20:22 +020012#include <linux/compiler.h>
Nikita Kiryanov36afd452015-11-08 17:11:49 +020013#include <errno.h>
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040014#include <asm/u-boot.h>
Nikita Kiryanov4188ba32015-11-08 17:11:44 +020015#include <errno.h>
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040016#include <mmc.h>
Tom Rinie4c444b2013-06-28 14:43:01 -040017#include <image.h>
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040018
19DECLARE_GLOBAL_DATA_PTR;
20
Simon Glass96debd12016-02-22 22:55:58 -070021static int mmc_load_legacy(struct mmc *mmc, ulong sector,
22 struct image_header *header)
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040023{
Peter Korsgaard2e222102013-03-21 04:55:17 +000024 u32 image_size_sectors;
Simon Glass96debd12016-02-22 22:55:58 -070025 unsigned long count;
Marek Vasut7e0f2262016-04-29 00:44:54 +020026 int ret;
Tom Rinie4c444b2013-06-28 14:43:01 -040027
Marek Vasut7e0f2262016-04-29 00:44:54 +020028 ret = spl_parse_image_header(header);
29 if (ret)
30 return ret;
31
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040032 /* convert size to sectors - round up */
Tom Rinif0881252012-08-14 10:25:15 -070033 image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) /
Paul Kocialkowski91199f42015-04-27 10:20:22 +020034 mmc->read_bl_len;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040035
36 /* Read the header too to avoid extra memcpy */
Simon Glassef5609c2016-05-14 14:03:06 -060037 count = blk_dread(mmc_get_blk_desc(mmc), sector, image_size_sectors,
38 (void *)(ulong)spl_image.load_addr);
Simon Glassfdfa39d2015-06-23 15:38:47 -060039 debug("read %x sectors to %x\n", image_size_sectors,
40 spl_image.load_addr);
Simon Glass96debd12016-02-22 22:55:58 -070041 if (count != image_size_sectors)
42 return -EIO;
43
44 return 0;
45}
46
Simon Glass96debd12016-02-22 22:55:58 -070047static ulong h_spl_load_read(struct spl_load_info *load, ulong sector,
48 ulong count, void *buf)
49{
50 struct mmc *mmc = load->dev;
51
Simon Glassef5609c2016-05-14 14:03:06 -060052 return blk_dread(mmc_get_blk_desc(mmc), sector, count, buf);
Simon Glass96debd12016-02-22 22:55:58 -070053}
Simon Glass96debd12016-02-22 22:55:58 -070054
55static int mmc_load_image_raw_sector(struct mmc *mmc, unsigned long sector)
56{
57 unsigned long count;
58 struct image_header *header;
59 int ret = 0;
60
61 header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
62 sizeof(struct image_header));
63
64 /* read image header to find the image size & load address */
Simon Glassef5609c2016-05-14 14:03:06 -060065 count = blk_dread(mmc_get_blk_desc(mmc), sector, 1, header);
Simon Glass96debd12016-02-22 22:55:58 -070066 debug("hdr read sector %lx, count=%lu\n", sector, count);
67 if (count == 0) {
68 ret = -EIO;
69 goto end;
70 }
71
Masahiro Yamada4976f482016-03-16 12:10:00 +090072 if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
73 image_get_magic(header) == FDT_MAGIC) {
Simon Glass96debd12016-02-22 22:55:58 -070074 struct spl_load_info load;
75
76 debug("Found FIT\n");
77 load.dev = mmc;
78 load.priv = NULL;
Lokesh Vutlaeafd5412016-05-24 10:34:38 +053079 load.filename = NULL;
Simon Glass96debd12016-02-22 22:55:58 -070080 load.bl_len = mmc->read_bl_len;
81 load.read = h_spl_load_read;
82 ret = spl_load_simple_fit(&load, sector, header);
Masahiro Yamada4976f482016-03-16 12:10:00 +090083 } else {
84 ret = mmc_load_legacy(mmc, sector, header);
Simon Glass96debd12016-02-22 22:55:58 -070085 }
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040086
87end:
Simon Glass96debd12016-02-22 22:55:58 -070088 if (ret) {
Paul Burton8112f5f2013-09-04 16:12:24 +010089#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
Fabio Estevam5bbf4092016-04-20 23:12:04 -030090 puts("mmc_load_image_raw_sector: mmc block read error\n");
Paul Burton8112f5f2013-09-04 16:12:24 +010091#endif
Paul Kocialkowski3bc37b62015-05-22 12:45:35 +020092 return -1;
Paul Kocialkowski1ec26462015-06-03 18:48:51 +020093 }
Paul Kocialkowski3bc37b62015-05-22 12:45:35 +020094
95 return 0;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -040096}
97
Nikita Kiryanova1e56cf2015-11-08 17:11:54 +020098int spl_mmc_get_device_index(u32 boot_device)
99{
100 switch (boot_device) {
101 case BOOT_DEVICE_MMC1:
102 return 0;
103 case BOOT_DEVICE_MMC2:
104 case BOOT_DEVICE_MMC2_2:
105 return 1;
106 }
107
108#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
109 printf("spl: unsupported mmc boot device.\n");
110#endif
111
112 return -ENODEV;
113}
114
Simon Glass99c7a512015-12-02 10:59:12 -0700115static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device)
Nikita Kiryanov4188ba32015-11-08 17:11:44 +0200116{
Simon Glassb4857aa2015-12-02 10:59:13 -0700117#ifdef CONFIG_DM_MMC
Nikita Kiryanov4188ba32015-11-08 17:11:44 +0200118 struct udevice *dev;
Simon Glassb4857aa2015-12-02 10:59:13 -0700119#endif
Nikita Kiryanova1e56cf2015-11-08 17:11:54 +0200120 int err, mmc_dev;
121
122 mmc_dev = spl_mmc_get_device_index(boot_device);
123 if (mmc_dev < 0)
124 return mmc_dev;
Nikita Kiryanov4188ba32015-11-08 17:11:44 +0200125
126 err = mmc_initialize(NULL);
127 if (err) {
128#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
129 printf("spl: could not initialize mmc. error: %d\n", err);
130#endif
131 return err;
132 }
133
Simon Glassb4857aa2015-12-02 10:59:13 -0700134#ifdef CONFIG_DM_MMC
Nikita Kiryanova1e56cf2015-11-08 17:11:54 +0200135 err = uclass_get_device(UCLASS_MMC, mmc_dev, &dev);
Simon Glassb4857aa2015-12-02 10:59:13 -0700136 if (!err)
137 *mmcp = mmc_get_mmc_dev(dev);
138#else
139 *mmcp = find_mmc_device(mmc_dev);
140 err = *mmcp ? 0 : -ENODEV;
141#endif
Nikita Kiryanov4188ba32015-11-08 17:11:44 +0200142 if (err) {
143#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
144 printf("spl: could not find mmc device. error: %d\n", err);
145#endif
146 return err;
147 }
148
Nikita Kiryanov4188ba32015-11-08 17:11:44 +0200149 return 0;
150}
Nikita Kiryanov4188ba32015-11-08 17:11:44 +0200151
Paul Kocialkowskib97300b2014-11-08 23:14:56 +0100152#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION
153static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
154{
155 disk_partition_t info;
Paul Kocialkowski3bc37b62015-05-22 12:45:35 +0200156 int err;
Paul Kocialkowskib97300b2014-11-08 23:14:56 +0100157
Simon Glass1e2b3ef2016-07-05 17:10:18 -0600158 err = part_get_info(mmc_get_blk_desc(mmc), partition, &info);
Paul Kocialkowski3bc37b62015-05-22 12:45:35 +0200159 if (err) {
Paul Kocialkowskib97300b2014-11-08 23:14:56 +0100160#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
Paul Kocialkowski1ec26462015-06-03 18:48:51 +0200161 puts("spl: partition error\n");
Paul Kocialkowskib97300b2014-11-08 23:14:56 +0100162#endif
163 return -1;
164 }
165
Stefan Roese4bfcc542015-07-20 11:20:39 +0200166#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR
167 return mmc_load_image_raw_sector(mmc, info.start +
168 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
169#else
Paul Kocialkowskib97300b2014-11-08 23:14:56 +0100170 return mmc_load_image_raw_sector(mmc, info.start);
Stefan Roese4bfcc542015-07-20 11:20:39 +0200171#endif
Paul Kocialkowskib97300b2014-11-08 23:14:56 +0100172}
Nikita Kiryanovd074ebb2015-11-08 17:11:46 +0200173#else
174#define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION -1
175static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
176{
177 return -ENOSYS;
178}
Paul Kocialkowskib97300b2014-11-08 23:14:56 +0100179#endif
180
Peter Korsgaard2b75b0a2013-05-13 08:36:29 +0000181#ifdef CONFIG_SPL_OS_BOOT
182static int mmc_load_image_raw_os(struct mmc *mmc)
183{
Paul Kocialkowski3bc37b62015-05-22 12:45:35 +0200184 unsigned long count;
Lokesh Vutla811906a2016-04-11 15:24:50 +0530185 int ret;
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200186
Simon Glass87bce4e2016-06-12 23:30:32 -0600187 count = blk_dread(mmc_get_blk_desc(mmc),
Paul Kocialkowski3bc37b62015-05-22 12:45:35 +0200188 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
189 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
190 (void *) CONFIG_SYS_SPL_ARGS_ADDR);
191 if (count == 0) {
Paul Burton8112f5f2013-09-04 16:12:24 +0100192#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
Fabio Estevam5bbf4092016-04-20 23:12:04 -0300193 puts("mmc_load_image_raw_os: mmc block read error\n");
Paul Burton8112f5f2013-09-04 16:12:24 +0100194#endif
Peter Korsgaard2b75b0a2013-05-13 08:36:29 +0000195 return -1;
196 }
197
Lokesh Vutla811906a2016-04-11 15:24:50 +0530198 ret = mmc_load_image_raw_sector(mmc,
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200199 CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR);
Lokesh Vutla811906a2016-04-11 15:24:50 +0530200 if (ret)
201 return ret;
202
203 if (spl_image.os != IH_OS_LINUX) {
204 puts("Expected Linux image is not found. Trying to start U-boot\n");
205 return -ENOENT;
206 }
207
208 return 0;
Peter Korsgaard2b75b0a2013-05-13 08:36:29 +0000209}
Nikita Kiryanov339245b2015-11-08 17:11:45 +0200210#else
211int spl_start_uboot(void)
212{
213 return 1;
214}
215static int mmc_load_image_raw_os(struct mmc *mmc)
216{
217 return -ENOSYS;
218}
Peter Korsgaard2b75b0a2013-05-13 08:36:29 +0000219#endif
220
Nikita Kiryanovf52b7292015-11-08 17:11:47 +0200221#ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
222int spl_mmc_do_fs_boot(struct mmc *mmc)
223{
224 int err = -ENOSYS;
225
226#ifdef CONFIG_SPL_FAT_SUPPORT
227 if (!spl_start_uboot()) {
Simon Glass87bce4e2016-06-12 23:30:32 -0600228 err = spl_load_image_fat_os(mmc_get_blk_desc(mmc),
Nikita Kiryanovf52b7292015-11-08 17:11:47 +0200229 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
230 if (!err)
231 return err;
232 }
233#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
Simon Glass87bce4e2016-06-12 23:30:32 -0600234 err = spl_load_image_fat(mmc_get_blk_desc(mmc),
Nikita Kiryanovf52b7292015-11-08 17:11:47 +0200235 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
236 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
237 if (!err)
238 return err;
239#endif
240#endif
241#ifdef CONFIG_SPL_EXT_SUPPORT
242 if (!spl_start_uboot()) {
243 err = spl_load_image_ext_os(&mmc->block_dev,
244 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
245 if (!err)
246 return err;
247 }
248#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
249 err = spl_load_image_ext(&mmc->block_dev,
250 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
251 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
252 if (!err)
253 return err;
254#endif
255#endif
256
257#if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT)
258 err = -ENOENT;
259#endif
260
261 return err;
262}
263#else
264int spl_mmc_do_fs_boot(struct mmc *mmc)
265{
266 return -ENOSYS;
267}
268#endif
269
Nikita Kiryanova1e56cf2015-11-08 17:11:54 +0200270int spl_mmc_load_image(u32 boot_device)
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400271{
Simon Glassd773a002015-12-02 10:59:11 -0700272 struct mmc *mmc = NULL;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400273 u32 boot_mode;
Simon Glassdc3dedf2015-06-23 15:38:51 -0600274 int err = 0;
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200275 __maybe_unused int part;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400276
Nikita Kiryanova1e56cf2015-11-08 17:11:54 +0200277 err = spl_mmc_find_device(&mmc, boot_device);
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200278 if (err)
279 return err;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400280
Nikita Kiryanov4188ba32015-11-08 17:11:44 +0200281 err = mmc_init(mmc);
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400282 if (err) {
Paul Burton8112f5f2013-09-04 16:12:24 +0100283#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200284 printf("spl: mmc init failed with error: %d\n", err);
Paul Burton8112f5f2013-09-04 16:12:24 +0100285#endif
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200286 return err;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400287 }
Peter Korsgaard79adb7a2013-05-13 08:36:25 +0000288
Marek Vasut2b1cdaf2016-05-14 23:42:07 +0200289 boot_mode = spl_boot_mode(boot_device);
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200290 err = -EINVAL;
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200291 switch (boot_mode) {
Nikita Kiryanov83cdf6f2015-11-08 17:11:48 +0200292 case MMCSD_MODE_EMMCBOOT:
293 /*
294 * We need to check what the partition is configured to.
295 * 1 and 2 match up to boot0 / boot1 and 7 is user data
296 * which is the first physical partition (0).
297 */
298 part = (mmc->part_config >> 3) & PART_ACCESS_MASK;
299
300 if (part == 7)
301 part = 0;
302
Simon Glass69f45cd2016-05-01 13:52:29 -0600303 err = blk_dselect_hwpart(mmc_get_blk_desc(mmc), part);
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200304 if (err) {
Nikita Kiryanov83cdf6f2015-11-08 17:11:48 +0200305#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
306 puts("spl: mmc partition switch failed\n");
307#endif
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200308 return err;
Nikita Kiryanov83cdf6f2015-11-08 17:11:48 +0200309 }
310 /* Fall through */
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200311 case MMCSD_MODE_RAW:
312 debug("spl: mmc boot mode: raw\n");
313
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200314 if (!spl_start_uboot()) {
315 err = mmc_load_image_raw_os(mmc);
316 if (!err)
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200317 return err;
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200318 }
Nikita Kiryanovd074ebb2015-11-08 17:11:46 +0200319
Paul Kocialkowskib97300b2014-11-08 23:14:56 +0100320 err = mmc_load_image_raw_partition(mmc,
321 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200322 if (!err)
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200323 return err;
Nikita Kiryanovd074ebb2015-11-08 17:11:46 +0200324#if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR)
Paul Kocialkowski3ae8f4c2015-06-08 23:05:09 +0200325 err = mmc_load_image_raw_sector(mmc,
326 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
327 if (!err)
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200328 return err;
Paul Kocialkowski3ae8f4c2015-06-08 23:05:09 +0200329#endif
Guillaume GARDET86a0df72016-02-18 18:17:36 +0100330 /* If RAW mode fails, try FS mode. */
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200331 case MMCSD_MODE_FS:
332 debug("spl: mmc boot mode: fs\n");
333
Nikita Kiryanovf52b7292015-11-08 17:11:47 +0200334 err = spl_mmc_do_fs_boot(mmc);
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200335 if (!err)
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200336 return err;
Nikita Kiryanovf52b7292015-11-08 17:11:47 +0200337
Nikita Kiryanovfd61d392015-11-08 17:11:43 +0200338 break;
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200339 case MMCSD_MODE_UNDEFINED:
Guillaume GARDET2c84c9a2014-12-16 12:00:44 +0100340#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
Nikita Kiryanovfd61d392015-11-08 17:11:43 +0200341 default:
342 puts("spl: mmc: wrong boot mode\n");
Guillaume GARDET2c84c9a2014-12-16 12:00:44 +0100343#endif
Paul Kocialkowski91199f42015-04-27 10:20:22 +0200344 }
Nikita Kiryanovfd61d392015-11-08 17:11:43 +0200345
Nikita Kiryanov36afd452015-11-08 17:11:49 +0200346 return err;
Simon Schwarz9ea5c6e2011-09-14 15:33:34 -0400347}