]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
9ea5c6ef SS |
2 | /* |
3 | * (C) Copyright 2010 | |
4 | * Texas Instruments, <www.ti.com> | |
5 | * | |
6 | * Aneesh V <aneesh@ti.com> | |
9ea5c6ef SS |
7 | */ |
8 | #include <common.h> | |
dc3dedfe | 9 | #include <dm.h> |
47f7bcae | 10 | #include <spl.h> |
91199f4a | 11 | #include <linux/compiler.h> |
36afd451 | 12 | #include <errno.h> |
9ea5c6ef | 13 | #include <asm/u-boot.h> |
4188ba32 | 14 | #include <errno.h> |
9ea5c6ef | 15 | #include <mmc.h> |
e4c444b3 | 16 | #include <image.h> |
9ea5c6ef | 17 | |
2a2ee2ac SG |
18 | static int mmc_load_legacy(struct spl_image_info *spl_image, struct mmc *mmc, |
19 | ulong sector, struct image_header *header) | |
96debd1f SG |
20 | { |
21 | u32 image_size_sectors; | |
22 | unsigned long count; | |
7e0f2267 MV |
23 | int ret; |
24 | ||
2a2ee2ac | 25 | ret = spl_parse_image_header(spl_image, header); |
7e0f2267 MV |
26 | if (ret) |
27 | return ret; | |
96debd1f | 28 | |
96debd1f | 29 | /* convert size to sectors - round up */ |
2a2ee2ac | 30 | image_size_sectors = (spl_image->size + mmc->read_bl_len - 1) / |
96debd1f SG |
31 | mmc->read_bl_len; |
32 | ||
33 | /* Read the header too to avoid extra memcpy */ | |
ef5609c3 | 34 | count = blk_dread(mmc_get_blk_desc(mmc), sector, image_size_sectors, |
2a2ee2ac | 35 | (void *)(ulong)spl_image->load_addr); |
11e1479b | 36 | debug("read %x sectors to %lx\n", image_size_sectors, |
2a2ee2ac | 37 | spl_image->load_addr); |
96debd1f SG |
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 | ||
ef5609c3 | 49 | return blk_dread(mmc_get_blk_desc(mmc), sector, count, buf); |
96debd1f | 50 | } |
96debd1f | 51 | |
e42afd84 BS |
52 | static __maybe_unused unsigned long spl_mmc_raw_uboot_offset(int part) |
53 | { | |
54 | #if IS_ENABLED(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR) | |
55 | if (part == 0) | |
56 | return CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_DATA_PART_OFFSET; | |
57 | #endif | |
58 | ||
59 | return 0; | |
60 | } | |
61 | ||
b016b585 SWK |
62 | static __maybe_unused |
63 | int mmc_load_image_raw_sector(struct spl_image_info *spl_image, | |
64 | struct mmc *mmc, unsigned long sector) | |
9ea5c6ef | 65 | { |
3bc37b6d | 66 | unsigned long count; |
2e222105 | 67 | struct image_header *header; |
04ce5427 | 68 | struct blk_desc *bd = mmc_get_blk_desc(mmc); |
96debd1f | 69 | int ret = 0; |
9ea5c6ef | 70 | |
04ce5427 | 71 | header = spl_get_load_buffer(-sizeof(*header), bd->blksz); |
9ea5c6ef SS |
72 | |
73 | /* read image header to find the image size & load address */ | |
04ce5427 | 74 | count = blk_dread(bd, sector, 1, header); |
96debd1f SG |
75 | debug("hdr read sector %lx, count=%lu\n", sector, count); |
76 | if (count == 0) { | |
77 | ret = -EIO; | |
9ea5c6ef | 78 | goto end; |
96debd1f | 79 | } |
9ea5c6ef | 80 | |
4976f482 MY |
81 | if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) && |
82 | image_get_magic(header) == FDT_MAGIC) { | |
96debd1f SG |
83 | struct spl_load_info load; |
84 | ||
85 | debug("Found FIT\n"); | |
86 | load.dev = mmc; | |
87 | load.priv = NULL; | |
eafd5410 | 88 | load.filename = NULL; |
96debd1f SG |
89 | load.bl_len = mmc->read_bl_len; |
90 | load.read = h_spl_load_read; | |
f4d7d859 | 91 | ret = spl_load_simple_fit(spl_image, &load, sector, header); |
dd7d0911 PF |
92 | } else if (IS_ENABLED(CONFIG_SPL_LOAD_IMX_CONTAINER)) { |
93 | struct spl_load_info load; | |
94 | ||
95 | load.dev = mmc; | |
96 | load.priv = NULL; | |
97 | load.filename = NULL; | |
98 | load.bl_len = mmc->read_bl_len; | |
99 | load.read = h_spl_load_read; | |
100 | ||
101 | ret = spl_load_imx_container(spl_image, &load, sector); | |
4976f482 | 102 | } else { |
2a2ee2ac | 103 | ret = mmc_load_legacy(spl_image, mmc, sector, header); |
fdfa39d3 | 104 | } |
e4c444b3 | 105 | |
9ea5c6ef | 106 | end: |
96debd1f | 107 | if (ret) { |
8112f5fa | 108 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
5bbf4099 | 109 | puts("mmc_load_image_raw_sector: mmc block read error\n"); |
8112f5fa | 110 | #endif |
3bc37b6d | 111 | return -1; |
1ec26469 | 112 | } |
3bc37b6d PK |
113 | |
114 | return 0; | |
9ea5c6ef SS |
115 | } |
116 | ||
207d8b35 | 117 | static int spl_mmc_get_device_index(u32 boot_device) |
a1e56cf6 NK |
118 | { |
119 | switch (boot_device) { | |
120 | case BOOT_DEVICE_MMC1: | |
121 | return 0; | |
122 | case BOOT_DEVICE_MMC2: | |
123 | case BOOT_DEVICE_MMC2_2: | |
124 | return 1; | |
125 | } | |
126 | ||
127 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT | |
128 | printf("spl: unsupported mmc boot device.\n"); | |
129 | #endif | |
130 | ||
131 | return -ENODEV; | |
132 | } | |
133 | ||
99c7a51a | 134 | static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device) |
4188ba32 | 135 | { |
a1e56cf6 NK |
136 | int err, mmc_dev; |
137 | ||
138 | mmc_dev = spl_mmc_get_device_index(boot_device); | |
139 | if (mmc_dev < 0) | |
140 | return mmc_dev; | |
4188ba32 | 141 | |
80f02019 LV |
142 | #if CONFIG_IS_ENABLED(DM_MMC) |
143 | err = mmc_init_device(mmc_dev); | |
144 | #else | |
4188ba32 | 145 | err = mmc_initialize(NULL); |
80f02019 | 146 | #endif /* DM_MMC */ |
4188ba32 NK |
147 | if (err) { |
148 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT | |
149 | printf("spl: could not initialize mmc. error: %d\n", err); | |
150 | #endif | |
151 | return err; | |
152 | } | |
b4857aa9 SG |
153 | *mmcp = find_mmc_device(mmc_dev); |
154 | err = *mmcp ? 0 : -ENODEV; | |
4188ba32 NK |
155 | if (err) { |
156 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT | |
aa608b6c AK |
157 | printf("spl: could not find mmc device %d. error: %d\n", |
158 | mmc_dev, err); | |
4188ba32 NK |
159 | #endif |
160 | return err; | |
161 | } | |
162 | ||
4188ba32 NK |
163 | return 0; |
164 | } | |
4188ba32 | 165 | |
949123e3 | 166 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION |
2a2ee2ac | 167 | static int mmc_load_image_raw_partition(struct spl_image_info *spl_image, |
e1eb6ada AD |
168 | struct mmc *mmc, int partition, |
169 | unsigned long sector) | |
b97300b6 PK |
170 | { |
171 | disk_partition_t info; | |
3bc37b6d | 172 | int err; |
b97300b6 | 173 | |
f0fb4fa7 DW |
174 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION_TYPE |
175 | int type_part; | |
176 | /* Only support MBR so DOS_ENTRY_NUMBERS */ | |
177 | for (type_part = 1; type_part <= DOS_ENTRY_NUMBERS; type_part++) { | |
178 | err = part_get_info(mmc_get_blk_desc(mmc), type_part, &info); | |
179 | if (err) | |
180 | continue; | |
181 | if (info.sys_ind == | |
182 | CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION_TYPE) { | |
183 | partition = type_part; | |
184 | break; | |
185 | } | |
186 | } | |
187 | #endif | |
188 | ||
1e2b3ef8 | 189 | err = part_get_info(mmc_get_blk_desc(mmc), partition, &info); |
3bc37b6d | 190 | if (err) { |
b97300b6 | 191 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
1ec26469 | 192 | puts("spl: partition error\n"); |
b97300b6 PK |
193 | #endif |
194 | return -1; | |
195 | } | |
196 | ||
38fed8ab | 197 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR |
e1eb6ada | 198 | return mmc_load_image_raw_sector(spl_image, mmc, info.start + sector); |
4bfcc54c | 199 | #else |
2a2ee2ac | 200 | return mmc_load_image_raw_sector(spl_image, mmc, info.start); |
4bfcc54c | 201 | #endif |
b97300b6 PK |
202 | } |
203 | #endif | |
204 | ||
2b75b0ad | 205 | #ifdef CONFIG_SPL_OS_BOOT |
2a2ee2ac SG |
206 | static int mmc_load_image_raw_os(struct spl_image_info *spl_image, |
207 | struct mmc *mmc) | |
2b75b0ad | 208 | { |
811906ae | 209 | int ret; |
91199f4a | 210 | |
7267fbf7 YS |
211 | #if defined(CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR) |
212 | unsigned long count; | |
213 | ||
87bce4e5 | 214 | count = blk_dread(mmc_get_blk_desc(mmc), |
3bc37b6d PK |
215 | CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR, |
216 | CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS, | |
217 | (void *) CONFIG_SYS_SPL_ARGS_ADDR); | |
9585dd3f | 218 | if (count != CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS) { |
8112f5fa | 219 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
5bbf4099 | 220 | puts("mmc_load_image_raw_os: mmc block read error\n"); |
8112f5fa | 221 | #endif |
2b75b0ad PK |
222 | return -1; |
223 | } | |
7267fbf7 | 224 | #endif /* CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR */ |
2b75b0ad | 225 | |
2a2ee2ac | 226 | ret = mmc_load_image_raw_sector(spl_image, mmc, |
91199f4a | 227 | CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR); |
811906ae LV |
228 | if (ret) |
229 | return ret; | |
230 | ||
2a2ee2ac | 231 | if (spl_image->os != IH_OS_LINUX) { |
811906ae LV |
232 | puts("Expected Linux image is not found. Trying to start U-boot\n"); |
233 | return -ENOENT; | |
234 | } | |
235 | ||
236 | return 0; | |
2b75b0ad | 237 | } |
339245b7 NK |
238 | #else |
239 | int spl_start_uboot(void) | |
240 | { | |
241 | return 1; | |
242 | } | |
2a2ee2ac SG |
243 | static int mmc_load_image_raw_os(struct spl_image_info *spl_image, |
244 | struct mmc *mmc) | |
339245b7 NK |
245 | { |
246 | return -ENOSYS; | |
247 | } | |
2b75b0ad PK |
248 | #endif |
249 | ||
f52b7293 | 250 | #ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION |
e1eb6ada AD |
251 | static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc, |
252 | const char *filename) | |
f52b7293 NK |
253 | { |
254 | int err = -ENOSYS; | |
255 | ||
0c3a9ed4 | 256 | #ifdef CONFIG_SPL_FS_FAT |
f52b7293 | 257 | if (!spl_start_uboot()) { |
710e9ca5 | 258 | err = spl_load_image_fat_os(spl_image, mmc_get_blk_desc(mmc), |
f52b7293 NK |
259 | CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); |
260 | if (!err) | |
261 | return err; | |
262 | } | |
263 | #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME | |
710e9ca5 | 264 | err = spl_load_image_fat(spl_image, mmc_get_blk_desc(mmc), |
f52b7293 | 265 | CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, |
e1eb6ada | 266 | filename); |
f52b7293 NK |
267 | if (!err) |
268 | return err; | |
269 | #endif | |
270 | #endif | |
f4b40924 | 271 | #ifdef CONFIG_SPL_FS_EXT4 |
f52b7293 | 272 | if (!spl_start_uboot()) { |
1a92541d | 273 | err = spl_load_image_ext_os(spl_image, mmc_get_blk_desc(mmc), |
f52b7293 NK |
274 | CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); |
275 | if (!err) | |
276 | return err; | |
277 | } | |
278 | #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME | |
1a92541d | 279 | err = spl_load_image_ext(spl_image, mmc_get_blk_desc(mmc), |
f52b7293 | 280 | CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, |
e1eb6ada | 281 | filename); |
f52b7293 NK |
282 | if (!err) |
283 | return err; | |
284 | #endif | |
285 | #endif | |
286 | ||
f4b40924 | 287 | #if defined(CONFIG_SPL_FS_FAT) || defined(CONFIG_SPL_FS_EXT4) |
f52b7293 NK |
288 | err = -ENOENT; |
289 | #endif | |
290 | ||
291 | return err; | |
292 | } | |
293 | #else | |
e1eb6ada AD |
294 | static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc, |
295 | const char *filename) | |
f52b7293 NK |
296 | { |
297 | return -ENOSYS; | |
298 | } | |
299 | #endif | |
300 | ||
e9759065 | 301 | u32 __weak spl_mmc_boot_mode(const u32 boot_device) |
d695d662 | 302 | { |
f4b40924 | 303 | #if defined(CONFIG_SPL_FS_FAT) || defined(CONFIG_SPL_FS_EXT4) |
d695d662 LM |
304 | return MMCSD_MODE_FS; |
305 | #elif defined(CONFIG_SUPPORT_EMMC_BOOT) | |
306 | return MMCSD_MODE_EMMCBOOT; | |
307 | #else | |
308 | return MMCSD_MODE_RAW; | |
309 | #endif | |
310 | } | |
311 | ||
35a66960 PD |
312 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION |
313 | __weak | |
314 | int spl_boot_partition(const u32 boot_device) | |
315 | { | |
316 | return CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION; | |
317 | } | |
318 | #endif | |
319 | ||
cf008255 FA |
320 | unsigned long __weak spl_mmc_get_uboot_raw_sector(struct mmc *mmc, |
321 | unsigned long raw_sect) | |
30ecc9c3 | 322 | { |
cf008255 | 323 | return raw_sect; |
30ecc9c3 PF |
324 | } |
325 | ||
e1eb6ada AD |
326 | int spl_mmc_load(struct spl_image_info *spl_image, |
327 | struct spl_boot_device *bootdev, | |
328 | const char *filename, | |
329 | int raw_part, | |
330 | unsigned long raw_sect) | |
9ea5c6ef | 331 | { |
e1eb6ada | 332 | static struct mmc *mmc; |
9ea5c6ef | 333 | u32 boot_mode; |
dc3dedfe | 334 | int err = 0; |
e42afd84 | 335 | __maybe_unused int part = 0; |
9ea5c6ef | 336 | |
e1eb6ada AD |
337 | /* Perform peripheral init only once */ |
338 | if (!mmc) { | |
339 | err = spl_mmc_find_device(&mmc, bootdev->boot_device); | |
340 | if (err) | |
341 | return err; | |
9ea5c6ef | 342 | |
e1eb6ada AD |
343 | err = mmc_init(mmc); |
344 | if (err) { | |
345 | mmc = NULL; | |
8112f5fa | 346 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
e1eb6ada | 347 | printf("spl: mmc init failed with error: %d\n", err); |
8112f5fa | 348 | #endif |
e1eb6ada AD |
349 | return err; |
350 | } | |
9ea5c6ef | 351 | } |
79adb7a2 | 352 | |
e9759065 | 353 | boot_mode = spl_mmc_boot_mode(bootdev->boot_device); |
36afd451 | 354 | err = -EINVAL; |
91199f4a | 355 | switch (boot_mode) { |
83cdf6fa | 356 | case MMCSD_MODE_EMMCBOOT: |
17241ea0 MR |
357 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_EMMC_BOOT_PARTITION |
358 | part = CONFIG_SYS_MMCSD_RAW_MODE_EMMC_BOOT_PARTITION; | |
359 | #else | |
9243990b MR |
360 | /* |
361 | * We need to check what the partition is configured to. | |
362 | * 1 and 2 match up to boot0 / boot1 and 7 is user data | |
363 | * which is the first physical partition (0). | |
364 | */ | |
365 | part = (mmc->part_config >> 3) & PART_ACCESS_MASK; | |
366 | ||
367 | if (part == 7) | |
368 | part = 0; | |
17241ea0 | 369 | #endif |
9243990b MR |
370 | |
371 | if (CONFIG_IS_ENABLED(MMC_TINY)) | |
372 | err = mmc_switch_part(mmc, part); | |
373 | else | |
374 | err = blk_dselect_hwpart(mmc_get_blk_desc(mmc), part); | |
375 | ||
376 | if (err) { | |
83cdf6fa | 377 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
9243990b | 378 | puts("spl: mmc partition switch failed\n"); |
83cdf6fa | 379 | #endif |
9243990b MR |
380 | return err; |
381 | } | |
382 | /* Fall through */ | |
91199f4a PK |
383 | case MMCSD_MODE_RAW: |
384 | debug("spl: mmc boot mode: raw\n"); | |
385 | ||
91199f4a | 386 | if (!spl_start_uboot()) { |
2a2ee2ac | 387 | err = mmc_load_image_raw_os(spl_image, mmc); |
91199f4a | 388 | if (!err) |
36afd451 | 389 | return err; |
91199f4a | 390 | } |
a335f805 | 391 | |
cf008255 | 392 | raw_sect = spl_mmc_get_uboot_raw_sector(mmc, raw_sect); |
a335f805 | 393 | |
949123e3 | 394 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION |
e1eb6ada AD |
395 | err = mmc_load_image_raw_partition(spl_image, mmc, raw_part, |
396 | raw_sect); | |
3ae8f4c8 | 397 | if (!err) |
36afd451 | 398 | return err; |
949123e3 | 399 | #endif |
38fed8ab | 400 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR |
e42afd84 BS |
401 | err = mmc_load_image_raw_sector(spl_image, mmc, |
402 | raw_sect + spl_mmc_raw_uboot_offset(part)); | |
91199f4a | 403 | if (!err) |
36afd451 | 404 | return err; |
3ae8f4c8 | 405 | #endif |
86a0df73 | 406 | /* If RAW mode fails, try FS mode. */ |
91199f4a PK |
407 | case MMCSD_MODE_FS: |
408 | debug("spl: mmc boot mode: fs\n"); | |
409 | ||
e1eb6ada | 410 | err = spl_mmc_do_fs_boot(spl_image, mmc, filename); |
91199f4a | 411 | if (!err) |
36afd451 | 412 | return err; |
f52b7293 | 413 | |
fd61d399 | 414 | break; |
8112f5fa | 415 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
fd61d399 NK |
416 | default: |
417 | puts("spl: mmc: wrong boot mode\n"); | |
8112f5fa | 418 | #endif |
91199f4a | 419 | } |
fd61d399 | 420 | |
36afd451 | 421 | return err; |
9ea5c6ef | 422 | } |
0fed9c7e | 423 | |
e1eb6ada AD |
424 | int spl_mmc_load_image(struct spl_image_info *spl_image, |
425 | struct spl_boot_device *bootdev) | |
426 | { | |
427 | return spl_mmc_load(spl_image, bootdev, | |
428 | #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME | |
429 | CONFIG_SPL_FS_LOAD_PAYLOAD_NAME, | |
430 | #else | |
431 | NULL, | |
432 | #endif | |
433 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION | |
434 | spl_boot_partition(bootdev->boot_device), | |
435 | #else | |
436 | 0, | |
437 | #endif | |
438 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR | |
439 | CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); | |
440 | #else | |
441 | 0); | |
442 | #endif | |
443 | } | |
444 | ||
ebc4ef61 SG |
445 | SPL_LOAD_IMAGE_METHOD("MMC1", 0, BOOT_DEVICE_MMC1, spl_mmc_load_image); |
446 | SPL_LOAD_IMAGE_METHOD("MMC2", 0, BOOT_DEVICE_MMC2, spl_mmc_load_image); | |
447 | SPL_LOAD_IMAGE_METHOD("MMC2_2", 0, BOOT_DEVICE_MMC2_2, spl_mmc_load_image); |