blob: a260137619806e3a0dd1ec41cb5bf8749be96b36 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Igor Grinbergf4a40f02014-11-03 11:32:20 +02002/*
3 * (C) Copyright 2014 CompuLab, Ltd. <www.compulab.co.il>
4 *
5 * Authors: Igor Grinberg <grinberg@compulab.co.il>
Igor Grinbergf4a40f02014-11-03 11:32:20 +02006 */
7
8#include <common.h>
Igor Grinbergf4a40f02014-11-03 11:32:20 +02009#include <bmp_layout.h>
Simon Glass288b29e2019-11-14 12:57:43 -070010#include <command.h>
Simon Glass7b51b572019-08-01 09:46:52 -060011#include <env.h>
tomas.melin@vaisala.com7583f1f2017-01-13 13:20:13 +020012#include <errno.h>
Nikita Kiryanov870dd302015-10-29 11:54:41 +020013#include <fs.h>
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +020014#include <fdt_support.h>
tomas.melin@vaisala.com7583f1f2017-01-13 13:20:13 +020015#include <image.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060016#include <log.h>
tomas.melin@vaisala.com7583f1f2017-01-13 13:20:13 +020017#include <nand.h>
18#include <sata.h>
19#include <spi.h>
20#include <spi_flash.h>
21#include <splash.h>
22#include <usb.h>
Simon Glassd8bf49f2021-11-19 13:24:05 -070023#include <virtio.h>
Simon Glass401d1c42020-10-30 21:38:53 -060024#include <asm/global_data.h>
Igor Grinbergf4a40f02014-11-03 11:32:20 +020025
26DECLARE_GLOBAL_DATA_PTR;
27
Nikita Kiryanov7e8d7f22015-01-14 10:42:52 +020028#ifdef CONFIG_SPI_FLASH
29static struct spi_flash *sf;
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020030static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
Nikita Kiryanov7e8d7f22015-01-14 10:42:52 +020031{
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
Jaehoon Chunga0b74ac2020-12-07 17:18:51 +090041 return spi_flash_read(sf, offset, read_size, (void *)(uintptr_t)bmp_load_addr);
Nikita Kiryanov7e8d7f22015-01-14 10:42:52 +020042}
43#else
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020044static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
Nikita Kiryanov7e8d7f22015-01-14 10:42:52 +020045{
46 debug("%s: sf support not available\n", __func__);
47 return -ENOSYS;
48}
49#endif
50
Igor Grinbergf4a40f02014-11-03 11:32:20 +020051#ifdef CONFIG_CMD_NAND
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020052static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020053{
Grygorii Strashkoedba8cc2017-06-26 19:12:56 -050054 struct mtd_info *mtd = get_nand_dev_by_index(nand_curr_device);
55 return nand_read_skip_bad(mtd, offset,
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020056 &read_size, NULL,
Grygorii Strashkoedba8cc2017-06-26 19:12:56 -050057 mtd->size,
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020058 (u_char *)bmp_load_addr);
59}
60#else
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020061static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020062{
63 debug("%s: nand support not available\n", __func__);
64 return -ENOSYS;
65}
66#endif
67
Julien Massona638d9a2022-10-17 10:33:21 +020068static 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
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020092static int splash_storage_read_raw(struct splash_location *location,
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +020093 u32 bmp_load_addr, size_t read_size)
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020094{
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +020095 u32 offset;
96
97 if (!location)
98 return -EINVAL;
99
100 offset = location->offset;
101 switch (location->storage) {
Julien Massona638d9a2022-10-17 10:33:21 +0200102 case SPLASH_STORAGE_MMC:
103 return splash_mmc_read_raw(bmp_load_addr, location, read_size);
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200104 case SPLASH_STORAGE_NAND:
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +0200105 return splash_nand_read_raw(bmp_load_addr, offset, read_size);
Nikita Kiryanov7e8d7f22015-01-14 10:42:52 +0200106 case SPLASH_STORAGE_SF:
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +0200107 return splash_sf_read_raw(bmp_load_addr, offset, read_size);
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200108 default:
109 printf("Unknown splash location\n");
110 }
111
112 return -EINVAL;
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +0200113}
114
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200115static int splash_load_raw(struct splash_location *location, u32 bmp_load_addr)
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200116{
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
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +0200124 res = splash_storage_read_raw(location, bmp_load_addr, bmp_header_size);
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200125 if (res < 0)
126 return res;
127
Jaehoon Chunga0b74ac2020-12-07 17:18:51 +0900128 bmp_hdr = (struct bmp_header *)(uintptr_t)bmp_load_addr;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200129 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
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +0200134 return splash_storage_read_raw(location, bmp_load_addr, bmp_size);
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200135
136splash_address_too_high:
Nikita Kiryanovf82eb2f2015-01-14 10:42:54 +0200137 printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200138
Nikita Kiryanov6947e3f2015-01-14 10:42:49 +0200139 return -EFAULT;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200140}
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200141
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200142static 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;
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200150 case SPLASH_STORAGE_USB:
151 res = fs_set_blk_dev("usb", location->devpart, FS_TYPE_ANY);
152 break;
Nikita Kiryanov50c2d2e2015-10-29 11:54:43 +0200153 case SPLASH_STORAGE_SATA:
154 res = fs_set_blk_dev("sata", location->devpart, FS_TYPE_ANY);
155 break;
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300156 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;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200162 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
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200173#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
Alexey Brodkind7b60fb2016-07-01 22:47:36 +0300182#ifndef CONFIG_DM_USB
183 err = usb_stor_scan(1) < 0 ? -ENODEV : 0;
184#endif
185
186 return err;
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200187}
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
Simon Glass10e40d52017-06-14 21:28:25 -0600196#ifdef CONFIG_SATA
Nikita Kiryanov50c2d2e2015-10-29 11:54:43 +0200197static int splash_init_sata(void)
198{
Simon Glassf19f1ec2017-07-29 11:35:13 -0600199 return sata_probe(0);
Nikita Kiryanov50c2d2e2015-10-29 11:54:43 +0200200}
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
Simon Glassd8bf49f2021-11-19 13:24:05 -0700209static 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
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300219#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
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200254#define SPLASH_SOURCE_DEFAULT_FILE_NAME "splash.bmp"
255
256static int splash_load_fs(struct splash_location *location, u32 bmp_load_addr)
257{
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200258 int res = 0;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200259 loff_t bmp_size;
Jonathan Golder3cc6e702017-02-24 17:46:10 +0100260 loff_t actread;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200261 char *splash_file;
262
Simon Glass00caae62017-08-03 12:22:12 -0600263 splash_file = env_get("splashfile");
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200264 if (!splash_file)
265 splash_file = SPLASH_SOURCE_DEFAULT_FILE_NAME;
266
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200267 if (location->storage == SPLASH_STORAGE_USB)
268 res = splash_init_usb();
269
Nikita Kiryanov50c2d2e2015-10-29 11:54:43 +0200270 if (location->storage == SPLASH_STORAGE_SATA)
271 res = splash_init_sata();
272
Simon Glassd8bf49f2021-11-19 13:24:05 -0700273 if (location->storage == SPLASH_STORAGE_VIRTIO)
274 res = splash_init_virtio();
275
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300276 if (location->ubivol != NULL)
277 res = splash_mount_ubifs(location);
278
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200279 if (res)
280 return res;
281
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200282 res = splash_select_fs_dev(location);
283 if (res)
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300284 goto out;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200285
286 res = fs_size(splash_file, &bmp_size);
287 if (res) {
288 printf("Error (%d): cannot determine file size\n", res);
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300289 goto out;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200290 }
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");
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300294 res = -EFAULT;
295 goto out;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200296 }
297
298 splash_select_fs_dev(location);
Jonathan Golder3cc6e702017-02-24 17:46:10 +0100299 res = fs_read(splash_file, bmp_load_addr, 0, 0, &actread);
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300300
301out:
302 if (location->ubivol != NULL)
303 splash_umount_ubifs();
304
305 return res;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200306}
307
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200308/**
309 * select_splash_location - return the splash location based on board support
310 * and env variable "splashsource".
311 *
312 * @locations: An array of supported splash locations.
313 * @size: Size of splash_locations array.
314 *
315 * @return: If a null set of splash locations is given, or
316 * splashsource env variable is set to unsupported value
317 * return NULL.
318 * If splashsource env variable is not defined
319 * return the first entry in splash_locations as default.
320 * If splashsource env variable contains a supported value
321 * return the location selected by splashsource.
322 */
323static struct splash_location *select_splash_location(
324 struct splash_location *locations, uint size)
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200325{
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200326 int i;
327 char *env_splashsource;
328
329 if (!locations || size == 0)
330 return NULL;
331
Simon Glass00caae62017-08-03 12:22:12 -0600332 env_splashsource = env_get("splashsource");
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200333 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
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200345#ifdef CONFIG_FIT
346static int splash_load_fit(struct splash_location *location, u32 bmp_load_addr)
347{
348 int res;
349 int node_offset;
Leo Ruan3d92f312019-02-08 10:51:35 +0100350 const char *splash_file;
Leo Ruand5006832019-02-08 10:51:36 +0100351 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;
Simon Glassf3543e62022-09-06 20:26:52 -0600356 struct legacy_img_hdr *img_header;
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200357 const u32 *fit_header;
358 u32 fit_size;
Simon Glassf3543e62022-09-06 20:26:52 -0600359 const size_t header_size = sizeof(struct legacy_img_hdr);
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200360
361 /* Read in image header */
362 res = splash_storage_read_raw(location, bmp_load_addr, header_size);
363 if (res < 0)
364 return res;
365
Simon Glassf3543e62022-09-06 20:26:52 -0600366 img_header = (struct legacy_img_hdr *)bmp_load_addr;
Niko Maunoa7126ed2017-08-03 09:53:24 +0300367 if (image_get_magic(img_header) != FDT_MAGIC) {
368 printf("Could not find FDT magic\n");
369 return -EINVAL;
370 }
371
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200372 fit_size = fdt_totalsize(img_header);
373
374 /* Read in entire FIT */
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
Simon Glassc5819702021-02-15 17:08:09 -0700380 res = fit_check_format(fit_header, IMAGE_SIZE_INVAL);
381 if (res) {
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200382 debug("Could not find valid FIT image\n");
Simon Glassc5819702021-02-15 17:08:09 -0700383 return res;
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200384 }
385
Leo Ruan3d92f312019-02-08 10:51:35 +0100386 /* Get the splash image node */
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);
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200392 if (node_offset < 0) {
393 debug("Could not find splash image '%s' in FIT\n",
Leo Ruan3d92f312019-02-08 10:51:35 +0100394 splash_file);
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200395 return -ENOENT;
396 }
397
Leo Ruand5006832019-02-08 10:51:36 +0100398 /* Extract the splash data from FIT */
399 /* 1. Test if splash is in FIT internal data. */
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 /* 2. Test if splash is in FIT external data with fixed position. */
403 else if (!fit_image_get_data_position(fit_header, node_offset, &external_splash_addr))
404 is_splash_external = true;
405 /* 3. Test if splash is in FIT external data with offset. */
406 else if (!fit_image_get_data_offset(fit_header, node_offset, &external_splash_addr)) {
407 /* Align data offset to 4-byte boundary */
408 fit_size = ALIGN(fdt_totalsize(fit_header), 4);
409 /* External splash offset means the offset by end of FIT header */
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;
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200415 }
416
Leo Ruand5006832019-02-08 10:51:36 +0100417 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 /* Read in the splash data */
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;
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200429 }
430
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200431 return 0;
432}
433#endif /* CONFIG_FIT */
434
Nikita Kiryanovf82eb2f2015-01-14 10:42:54 +0200435/**
436 * splash_source_load - load splash image from a supported location.
437 *
438 * Select a splash image location based on the value of splashsource environment
439 * variable and the board supported splash source locations, and load a
440 * splashimage to the address pointed to by splashimage environment variable.
441 *
442 * @locations: An array of supported splash locations.
443 * @size: Size of splash_locations array.
444 *
445 * @return: 0 on success, negative value on failure.
446 */
447int splash_source_load(struct splash_location *locations, uint size)
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200448{
449 struct splash_location *splash_location;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200450 char *env_splashimage_value;
Julien Masson7fcb30c2022-10-17 10:33:22 +0200451 char *devpart;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200452 u32 bmp_load_addr;
453
Simon Glass00caae62017-08-03 12:22:12 -0600454 env_splashimage_value = env_get("splashimage");
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200455 if (env_splashimage_value == NULL)
Nikita Kiryanov6947e3f2015-01-14 10:42:49 +0200456 return -ENOENT;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200457
Simon Glass7e5f4602021-07-24 09:03:29 -0600458 bmp_load_addr = hextoul(env_splashimage_value, 0);
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200459 if (bmp_load_addr == 0) {
460 printf("Error: bad splashimage address specified\n");
Nikita Kiryanov6947e3f2015-01-14 10:42:49 +0200461 return -EFAULT;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200462 }
463
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200464 splash_location = select_splash_location(locations, size);
465 if (!splash_location)
466 return -EINVAL;
467
Julien Masson7fcb30c2022-10-17 10:33:22 +0200468 devpart = env_get("splashdevpart");
469 if (devpart)
470 splash_location->devpart = devpart;
471
tomas.melin@vaisala.com3b593f92016-11-16 13:02:32 +0200472 if (splash_location->flags == SPLASH_STORAGE_RAW)
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200473 return splash_load_raw(splash_location, bmp_load_addr);
tomas.melin@vaisala.com3b593f92016-11-16 13:02:32 +0200474 else if (splash_location->flags == SPLASH_STORAGE_FS)
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200475 return splash_load_fs(splash_location, bmp_load_addr);
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200476#ifdef CONFIG_FIT
477 else if (splash_location->flags == SPLASH_STORAGE_FIT)
478 return splash_load_fit(splash_location, bmp_load_addr);
479#endif
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200480 return -EINVAL;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200481}