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