1
2
3
4
5
6
7
8#include <common.h>
9#include <bmp_layout.h>
10#include <command.h>
11#include <env.h>
12#include <errno.h>
13#include <fs.h>
14#include <fdt_support.h>
15#include <image.h>
16#include <log.h>
17#include <nand.h>
18#include <sata.h>
19#include <spi.h>
20#include <spi_flash.h>
21#include <splash.h>
22#include <usb.h>
23#include <virtio.h>
24#include <asm/global_data.h>
25
26DECLARE_GLOBAL_DATA_PTR;
27
28#ifdef CONFIG_SPI_FLASH
29static struct spi_flash *sf;
30static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
31{
32 if (!sf) {
33 sf = spi_flash_probe(CONFIG_SF_DEFAULT_BUS,
34 CONFIG_SF_DEFAULT_CS,
35 CONFIG_SF_DEFAULT_SPEED,
36 CONFIG_SF_DEFAULT_MODE);
37 if (!sf)
38 return -ENODEV;
39 }
40
41 return spi_flash_read(sf, offset, read_size, (void *)(uintptr_t)bmp_load_addr);
42}
43#else
44static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
45{
46 debug("%s: sf support not available\n", __func__);
47 return -ENOSYS;
48}
49#endif
50
51#ifdef CONFIG_CMD_NAND
52static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
53{
54 struct mtd_info *mtd = get_nand_dev_by_index(nand_curr_device);
55 return nand_read_skip_bad(mtd, offset,
56 &read_size, NULL,
57 mtd->size,
58 (u_char *)bmp_load_addr);
59}
60#else
61static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
62{
63 debug("%s: nand support not available\n", __func__);
64 return -ENOSYS;
65}
66#endif
67
68static int splash_mmc_read_raw(u32 bmp_load_addr, struct splash_location *location,
69 size_t read_size)
70{
71 struct disk_partition partition;
72 struct blk_desc *desc;
73 lbaint_t blkcnt;
74 int ret, n;
75
76 if (!IS_ENABLED(CONFIG_CMD_MMC)) {
77 debug("%s: mmc support not available\n", __func__);
78 return -ENOSYS;
79 }
80
81 ret = part_get_info_by_dev_and_name_or_num("mmc", location->devpart, &desc,
82 &partition, 1);
83 if (ret < 0)
84 return ret;
85
86 blkcnt = DIV_ROUND_UP(read_size, partition.blksz);
87 n = blk_dread(desc, partition.start, blkcnt, (void *)(uintptr_t)bmp_load_addr);
88
89 return (n == blkcnt) ? 0 : -EIO;
90}
91
92static int splash_storage_read_raw(struct splash_location *location,
93 u32 bmp_load_addr, size_t read_size)
94{
95 u32 offset;
96
97 if (!location)
98 return -EINVAL;
99
100 offset = location->offset;
101 switch (location->storage) {
102 case SPLASH_STORAGE_MMC:
103 return splash_mmc_read_raw(bmp_load_addr, location, read_size);
104 case SPLASH_STORAGE_NAND:
105 return splash_nand_read_raw(bmp_load_addr, offset, read_size);
106 case SPLASH_STORAGE_SF:
107 return splash_sf_read_raw(bmp_load_addr, offset, read_size);
108 default:
109 printf("Unknown splash location\n");
110 }
111
112 return -EINVAL;
113}
114
115static int splash_load_raw(struct splash_location *location, u32 bmp_load_addr)
116{
117 struct bmp_header *bmp_hdr;
118 int res;
119 size_t bmp_size, bmp_header_size = sizeof(struct bmp_header);
120
121 if (bmp_load_addr + bmp_header_size >= gd->start_addr_sp)
122 goto splash_address_too_high;
123
124 res = splash_storage_read_raw(location, bmp_load_addr, bmp_header_size);
125 if (res < 0)
126 return res;
127
128 bmp_hdr = (struct bmp_header *)(uintptr_t)bmp_load_addr;
129 bmp_size = le32_to_cpu(bmp_hdr->file_size);
130
131 if (bmp_load_addr + bmp_size >= gd->start_addr_sp)
132 goto splash_address_too_high;
133
134 return splash_storage_read_raw(location, bmp_load_addr, bmp_size);
135
136splash_address_too_high:
137 printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
138
139 return -EFAULT;
140}
141
142static int splash_select_fs_dev(struct splash_location *location)
143{
144 int res;
145
146 switch (location->storage) {
147 case SPLASH_STORAGE_MMC:
148 res = fs_set_blk_dev("mmc", location->devpart, FS_TYPE_ANY);
149 break;
150 case SPLASH_STORAGE_USB:
151 res = fs_set_blk_dev("usb", location->devpart, FS_TYPE_ANY);
152 break;
153 case SPLASH_STORAGE_SATA:
154 res = fs_set_blk_dev("sata", location->devpart, FS_TYPE_ANY);
155 break;
156 case SPLASH_STORAGE_NAND:
157 if (location->ubivol != NULL)
158 res = fs_set_blk_dev("ubi", NULL, FS_TYPE_UBIFS);
159 else
160 res = -ENODEV;
161 break;
162 default:
163 printf("Error: unsupported location storage.\n");
164 return -ENODEV;
165 }
166
167 if (res)
168 printf("Error: could not access storage.\n");
169
170 return res;
171}
172
173#ifdef CONFIG_USB_STORAGE
174static int splash_init_usb(void)
175{
176 int err;
177
178 err = usb_init();
179 if (err)
180 return err;
181
182#ifndef CONFIG_DM_USB
183 err = usb_stor_scan(1) < 0 ? -ENODEV : 0;
184#endif
185
186 return err;
187}
188#else
189static inline int splash_init_usb(void)
190{
191 printf("Cannot load splash image: no USB support\n");
192 return -ENOSYS;
193}
194#endif
195
196#ifdef CONFIG_SATA
197static int splash_init_sata(void)
198{
199 return sata_probe(0);
200}
201#else
202static inline int splash_init_sata(void)
203{
204 printf("Cannot load splash image: no SATA support\n");
205 return -ENOSYS;
206}
207#endif
208
209static int splash_init_virtio(void)
210{
211 if (!IS_ENABLED(CONFIG_VIRTIO)) {
212 printf("Cannot load splash image: no virtio support\n");
213 return -ENOSYS;
214 } else {
215 return virtio_init();
216 }
217}
218
219#ifdef CONFIG_CMD_UBIFS
220static int splash_mount_ubifs(struct splash_location *location)
221{
222 int res;
223 char cmd[32];
224
225 sprintf(cmd, "ubi part %s", location->mtdpart);
226 res = run_command(cmd, 0);
227 if (res)
228 return res;
229
230 sprintf(cmd, "ubifsmount %s", location->ubivol);
231 res = run_command(cmd, 0);
232
233 return res;
234}
235
236static inline int splash_umount_ubifs(void)
237{
238 return run_command("ubifsumount", 0);
239}
240#else
241static inline int splash_mount_ubifs(struct splash_location *location)
242{
243 printf("Cannot load splash image: no UBIFS support\n");
244 return -ENOSYS;
245}
246
247static inline int splash_umount_ubifs(void)
248{
249 printf("Cannot unmount UBIFS: no UBIFS support\n");
250 return -ENOSYS;
251}
252#endif
253
254#define SPLASH_SOURCE_DEFAULT_FILE_NAME "splash.bmp"
255
256static int splash_load_fs(struct splash_location *location, u32 bmp_load_addr)
257{
258 int res = 0;
259 loff_t bmp_size;
260 loff_t actread;
261 char *splash_file;
262
263 splash_file = env_get("splashfile");
264 if (!splash_file)
265 splash_file = SPLASH_SOURCE_DEFAULT_FILE_NAME;
266
267 if (location->storage == SPLASH_STORAGE_USB)
268 res = splash_init_usb();
269
270 if (location->storage == SPLASH_STORAGE_SATA)
271 res = splash_init_sata();
272
273 if (location->storage == SPLASH_STORAGE_VIRTIO)
274 res = splash_init_virtio();
275
276 if (location->ubivol != NULL)
277 res = splash_mount_ubifs(location);
278
279 if (res)
280 return res;
281
282 res = splash_select_fs_dev(location);
283 if (res)
284 goto out;
285
286 res = fs_size(splash_file, &bmp_size);
287 if (res) {
288 printf("Error (%d): cannot determine file size\n", res);
289 goto out;
290 }
291
292 if (bmp_load_addr + bmp_size >= gd->start_addr_sp) {
293 printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
294 res = -EFAULT;
295 goto out;
296 }
297
298 splash_select_fs_dev(location);
299 res = fs_read(splash_file, bmp_load_addr, 0, 0, &actread);
300
301out:
302 if (location->ubivol != NULL)
303 splash_umount_ubifs();
304
305 return res;
306}
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323static struct splash_location *select_splash_location(
324 struct splash_location *locations, uint size)
325{
326 int i;
327 char *env_splashsource;
328
329 if (!locations || size == 0)
330 return NULL;
331
332 env_splashsource = env_get("splashsource");
333 if (env_splashsource == NULL)
334 return &locations[0];
335
336 for (i = 0; i < size; i++) {
337 if (!strcmp(locations[i].name, env_splashsource))
338 return &locations[i];
339 }
340
341 printf("splashsource env variable set to unsupported value\n");
342 return NULL;
343}
344
345#ifdef CONFIG_FIT
346static int splash_load_fit(struct splash_location *location, u32 bmp_load_addr)
347{
348 int res;
349 int node_offset;
350 const char *splash_file;
351 const void *internal_splash_data;
352 size_t internal_splash_size;
353 int external_splash_addr;
354 int external_splash_size;
355 bool is_splash_external = false;
356 struct legacy_img_hdr *img_header;
357 const u32 *fit_header;
358 u32 fit_size;
359 const size_t header_size = sizeof(struct legacy_img_hdr);
360
361
362 res = splash_storage_read_raw(location, bmp_load_addr, header_size);
363 if (res < 0)
364 return res;
365
366 img_header = (struct legacy_img_hdr *)bmp_load_addr;
367 if (image_get_magic(img_header) != FDT_MAGIC) {
368 printf("Could not find FDT magic\n");
369 return -EINVAL;
370 }
371
372 fit_size = fdt_totalsize(img_header);
373
374
375 fit_header = (const u32 *)(bmp_load_addr + header_size);
376 res = splash_storage_read_raw(location, (u32)fit_header, fit_size);
377 if (res < 0)
378 return res;
379
380 res = fit_check_format(fit_header, IMAGE_SIZE_INVAL);
381 if (res) {
382 debug("Could not find valid FIT image\n");
383 return res;
384 }
385
386
387 splash_file = env_get("splashfile");
388 if (!splash_file)
389 splash_file = SPLASH_SOURCE_DEFAULT_FILE_NAME;
390
391 node_offset = fit_image_get_node(fit_header, splash_file);
392 if (node_offset < 0) {
393 debug("Could not find splash image '%s' in FIT\n",
394 splash_file);
395 return -ENOENT;
396 }
397
398
399
400 if (!fit_image_get_data(fit_header, node_offset, &internal_splash_data, &internal_splash_size))
401 memmove((void *)bmp_load_addr, internal_splash_data, internal_splash_size);
402
403 else if (!fit_image_get_data_position(fit_header, node_offset, &external_splash_addr))
404 is_splash_external = true;
405
406 else if (!fit_image_get_data_offset(fit_header, node_offset, &external_splash_addr)) {
407
408 fit_size = ALIGN(fdt_totalsize(fit_header), 4);
409
410 external_splash_addr += location->offset + fit_size;
411 is_splash_external = true;
412 } else {
413 printf("Failed to get splash image from FIT\n");
414 return -ENODATA;
415 }
416
417 if (is_splash_external) {
418 res = fit_image_get_data_size(fit_header, node_offset, &external_splash_size);
419 if (res < 0) {
420 printf("Failed to get size of splash image (err=%d)\n", res);
421 return res;
422 }
423
424
425 location->offset = external_splash_addr;
426 res = splash_storage_read_raw(location, bmp_load_addr, external_splash_size);
427 if (res < 0)
428 return res;
429 }
430
431 return 0;
432}
433#endif
434
435
436
437
438
439
440
441
442
443
444
445
446
447int splash_source_load(struct splash_location *locations, uint size)
448{
449 struct splash_location *splash_location;
450 char *env_splashimage_value;
451 char *devpart;
452 u32 bmp_load_addr;
453
454 env_splashimage_value = env_get("splashimage");
455 if (env_splashimage_value == NULL)
456 return -ENOENT;
457
458 bmp_load_addr = hextoul(env_splashimage_value, 0);
459 if (bmp_load_addr == 0) {
460 printf("Error: bad splashimage address specified\n");
461 return -EFAULT;
462 }
463
464 splash_location = select_splash_location(locations, size);
465 if (!splash_location)
466 return -EINVAL;
467
468 devpart = env_get("splashdevpart");
469 if (devpart)
470 splash_location->devpart = devpart;
471
472 if (splash_location->flags == SPLASH_STORAGE_RAW)
473 return splash_load_raw(splash_location, bmp_load_addr);
474 else if (splash_location->flags == SPLASH_STORAGE_FS)
475 return splash_load_fs(splash_location, bmp_load_addr);
476#ifdef CONFIG_FIT
477 else if (splash_location->flags == SPLASH_STORAGE_FIT)
478 return splash_load_fit(splash_location, bmp_load_addr);
479#endif
480 return -EINVAL;
481}
482
