1 /*
2 * (C) Copyright 2010
3 * Texas Instruments, <www.ti.com>
4 *
5 * Aneesh V <aneesh@ti.com>
6 *
7 * SPDX-License-Identifier: GPL-2.0+
8 */
9 #include <common.h>
10 #include <boot_rkimg.h>
11 #include <dm.h>
12 #include <part.h>
13 #include <spl.h>
14 #include <spl_rkfw.h>
15 #include <linux/compiler.h>
16 #include <errno.h>
17 #include <asm/u-boot.h>
18 #include <errno.h>
19 #include <mmc.h>
20 #include <image.h>
21
22 DECLARE_GLOBAL_DATA_PTR;
23
mmc_load_legacy(struct spl_image_info * spl_image,struct mmc * mmc,ulong sector,struct image_header * header)24 static int mmc_load_legacy(struct spl_image_info *spl_image, struct mmc *mmc,
25 ulong sector, struct image_header *header)
26 {
27 u32 image_size_sectors;
28 unsigned long count;
29 int ret;
30
31 ret = spl_parse_image_header(spl_image, header);
32 if (ret)
33 return ret;
34
35 /* convert size to sectors - round up */
36 image_size_sectors = (spl_image->size + mmc->read_bl_len - 1) /
37 mmc->read_bl_len;
38
39 /* Read the header too to avoid extra memcpy */
40 count = blk_dread(mmc_get_blk_desc(mmc), sector, image_size_sectors,
41 (void *)(ulong)spl_image->load_addr);
42 debug("read %x sectors to %lx\n", image_size_sectors,
43 spl_image->load_addr);
44 if (count != image_size_sectors)
45 return -EIO;
46
47 return 0;
48 }
49
h_spl_load_read(struct spl_load_info * load,ulong sector,ulong count,void * buf)50 static ulong h_spl_load_read(struct spl_load_info *load, ulong sector,
51 ulong count, void *buf)
52 {
53 return blk_dread(load->dev, sector, count, buf);
54 }
55
56 static __maybe_unused
mmc_load_image_raw_sector(struct spl_image_info * spl_image,struct mmc * mmc,unsigned long sector)57 int mmc_load_image_raw_sector(struct spl_image_info *spl_image,
58 struct mmc *mmc, unsigned long sector)
59 {
60 unsigned long count;
61 struct image_header *header;
62 int ret = 0;
63
64 header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
65 sizeof(struct image_header));
66
67 /* read image header to find the image size & load address */
68 count = blk_dread(mmc_get_blk_desc(mmc), sector, 1, header);
69 debug("hdr read sector %lx, count=%lu\n", sector, count);
70 if (count == 0) {
71 ret = -EIO;
72 goto end;
73 }
74
75 #ifdef CONFIG_SPL_FIT_IMAGE_MULTIPLE
76 if ((IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
77 image_get_magic(header) == FDT_MAGIC) ||
78 CONFIG_SPL_FIT_IMAGE_MULTIPLE > 1) {
79 #else
80 if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
81 image_get_magic(header) == FDT_MAGIC) {
82 #endif
83 struct spl_load_info load;
84
85 debug("Found FIT\n");
86 load.dev = mmc_get_blk_desc(mmc);
87 load.priv = NULL;
88 load.filename = NULL;
89 load.bl_len = mmc->read_bl_len;
90 load.read = h_spl_load_read;
91 ret = spl_load_simple_fit(spl_image, &load, sector, header);
92 } else {
93 ret = mmc_load_legacy(spl_image, mmc, sector, header);
94 }
95
96 end:
97 if (ret) {
98 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
99 debug("mmc_load_image_raw_sector error: ret is %d\n", ret);
100 #endif
101 return -1;
102 }
103
104 return 0;
105 }
106
107 static int spl_mmc_get_device_index(u32 boot_device)
108 {
109 switch (boot_device) {
110 case BOOT_DEVICE_MMC1:
111 return 0;
112 case BOOT_DEVICE_MMC2:
113 case BOOT_DEVICE_MMC2_2:
114 return 1;
115 }
116
117 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
118 printf("spl: unsupported mmc boot device.\n");
119 #endif
120
121 return -ENODEV;
122 }
123
124 int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device)
125 {
126 int err, mmc_dev;
127
128 mmc_dev = spl_mmc_get_device_index(boot_device);
129 if (mmc_dev < 0)
130 return mmc_dev;
131
132 err = mmc_initialize(NULL);
133 if (err) {
134 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
135 printf("spl: could not initialize mmc. error: %d\n", err);
136 #endif
137 return err;
138 }
139
140 *mmcp = find_mmc_device(mmc_dev);
141 err = *mmcp ? 0 : -ENODEV;
142 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
149 return 0;
150 }
151
152 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION
153 static int mmc_load_image_raw_partition(struct spl_image_info *spl_image,
154 struct mmc *mmc,
155 const char *partition_name,
156 int partition)
157 {
158 disk_partition_t info;
159 int err;
160
161 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION_TYPE
162 int type_part;
163 /* Only support MBR so DOS_ENTRY_NUMBERS */
164 for (type_part = 1; type_part <= DOS_ENTRY_NUMBERS; type_part++) {
165 err = part_get_info(mmc_get_blk_desc(mmc), type_part, &info);
166 if (err)
167 continue;
168 if (info.sys_ind ==
169 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION_TYPE) {
170 partition = type_part;
171 break;
172 }
173 }
174 #endif
175 if (strcmp(partition_name, ""))
176 err = part_get_info_by_name(mmc_get_blk_desc(mmc),
177 partition_name, &info);
178 else
179 err = part_get_info(mmc_get_blk_desc(mmc), partition, &info);
180 if (err < 0) {
181 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
182 puts("spl: partition error\n");
183 #endif
184 return -1;
185 }
186
187 return mmc_load_image_raw_sector(spl_image, mmc, info.start);
188 }
189 #endif
190
191 #ifdef CONFIG_SPL_OS_BOOT
192 static int mmc_load_image_raw_os(struct spl_image_info *spl_image,
193 struct mmc *mmc)
194 {
195 unsigned long count;
196 int ret;
197
198 count = blk_dread(mmc_get_blk_desc(mmc),
199 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
200 CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
201 (void *) CONFIG_SYS_SPL_ARGS_ADDR);
202 if (count != CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS) {
203 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
204 puts("mmc_load_image_raw_os: mmc block read error\n");
205 #endif
206 return -1;
207 }
208
209 ret = mmc_load_image_raw_sector(spl_image, mmc,
210 CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR);
211 if (ret)
212 return ret;
213
214 if (spl_image->os != IH_OS_LINUX) {
215 puts("Expected Linux image is not found. Trying to start U-boot\n");
216 return -ENOENT;
217 }
218
219 return 0;
220 }
221 #else
222 int spl_start_uboot(void)
223 {
224 return 1;
225 }
226 static int mmc_load_image_raw_os(struct spl_image_info *spl_image,
227 struct mmc *mmc)
228 {
229 return -ENOSYS;
230 }
231 #endif
232
233 #ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
234 static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc)
235 {
236 int err = -ENOSYS;
237
238 #ifdef CONFIG_SPL_FAT_SUPPORT
239 if (!spl_start_uboot()) {
240 err = spl_load_image_fat_os(spl_image, mmc_get_blk_desc(mmc),
241 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
242 if (!err)
243 return err;
244 }
245 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
246 err = spl_load_image_fat(spl_image, mmc_get_blk_desc(mmc),
247 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
248 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
249 if (!err)
250 return err;
251 #endif
252 #endif
253 #ifdef CONFIG_SPL_EXT_SUPPORT
254 if (!spl_start_uboot()) {
255 err = spl_load_image_ext_os(spl_image, mmc_get_blk_desc(mmc),
256 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
257 if (!err)
258 return err;
259 }
260 #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
261 err = spl_load_image_ext(spl_image, mmc_get_blk_desc(mmc),
262 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
263 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
264 if (!err)
265 return err;
266 #endif
267 #endif
268
269 #if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT)
270 err = -ENOENT;
271 #endif
272
273 return err;
274 }
275 #else
276 static int spl_mmc_do_fs_boot(struct spl_image_info *spl_image, struct mmc *mmc)
277 {
278 return -ENOSYS;
279 }
280 #endif
281
282 int spl_mmc_load_image(struct spl_image_info *spl_image,
283 struct spl_boot_device *bootdev)
284 {
285 struct mmc *mmc = NULL;
286 u32 boot_mode;
287 int err = 0;
288 __maybe_unused int part;
289
290 err = spl_mmc_find_device(&mmc, bootdev->boot_device);
291 if (err)
292 return err;
293
294 err = mmc_init(mmc);
295 if (err) {
296 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
297 printf("spl: mmc init failed with error: %d\n", err);
298 #endif
299 return err;
300 }
301
302 #ifdef CONFIG_SPL_LOAD_RKFW
303 struct spl_load_info load;
304
305 load.dev = mmc_get_blk_desc(mmc);
306 load.priv = NULL;
307 load.filename = NULL;
308 load.bl_len = mmc->read_bl_len;
309 load.read = h_spl_load_read;
310
311 err = spl_load_rkfw_image(spl_image, &load);
312 if (!err || err != -EAGAIN)
313 return err;
314 #endif
315 boot_mode = spl_boot_mode(bootdev->boot_device);
316 err = -EINVAL;
317 switch (boot_mode) {
318 case MMCSD_MODE_EMMCBOOT:
319 /*
320 * We need to check what the partition is configured to.
321 * 1 and 2 match up to boot0 / boot1 and 7 is user data
322 * which is the first physical partition (0).
323 */
324 part = (mmc->part_config >> 3) & PART_ACCESS_MASK;
325
326 if (part == 7)
327 part = 0;
328
329 if (CONFIG_IS_ENABLED(MMC_TINY))
330 err = mmc_switch_part(mmc, part);
331 else
332 err = blk_dselect_hwpart(mmc_get_blk_desc(mmc), part);
333
334 if (err) {
335 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
336 puts("spl: mmc partition switch failed\n");
337 #endif
338 return err;
339 }
340 /* Fall through */
341 case MMCSD_MODE_RAW:
342 debug("spl: mmc boot mode: raw\n");
343
344 if (!spl_start_uboot()) {
345 err = mmc_load_image_raw_os(spl_image, mmc);
346 if (!err)
347 return err;
348 }
349 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_PARTITION
350 err = mmc_load_image_raw_partition(spl_image, mmc,
351 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION_NAME,
352 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
353 if (!err)
354 return err;
355 #endif
356 #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR
357 err = mmc_load_image_raw_sector(spl_image, mmc,
358 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
359 if (!err)
360 return err;
361 #endif
362 /* If RAW mode fails, try FS mode. */
363 case MMCSD_MODE_FS:
364 debug("spl: mmc boot mode: fs\n");
365
366 err = spl_mmc_do_fs_boot(spl_image, mmc);
367 if (!err)
368 return err;
369
370 break;
371 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
372 default:
373 puts("spl: mmc: wrong boot mode\n");
374 #endif
375 }
376
377 return err;
378 }
379
380 SPL_LOAD_IMAGE_METHOD("MMC1", 0, BOOT_DEVICE_MMC1, spl_mmc_load_image);
381 SPL_LOAD_IMAGE_METHOD("MMC2", 0, BOOT_DEVICE_MMC2, spl_mmc_load_image);
382 SPL_LOAD_IMAGE_METHOD("MMC2_2", 0, BOOT_DEVICE_MMC2_2, spl_mmc_load_image);
383