blob: 867a7984870ddeae0e167d55911627f846ae7783 [file] [log] [blame]
Igor Grinbergf4a40f02014-11-03 11:32:20 +02001/*
2 * (C) Copyright 2014 CompuLab, Ltd. <www.compulab.co.il>
3 *
4 * Authors: Igor Grinberg <grinberg@compulab.co.il>
5 *
6 * SPDX-License-Identifier: GPL-2.0+
7 */
8
9#include <common.h>
Igor Grinbergf4a40f02014-11-03 11:32:20 +020010#include <bmp_layout.h>
tomas.melin@vaisala.com7583f1f2017-01-13 13:20:13 +020011#include <errno.h>
Nikita Kiryanov870dd302015-10-29 11:54:41 +020012#include <fs.h>
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +020013#include <fdt_support.h>
tomas.melin@vaisala.com7583f1f2017-01-13 13:20:13 +020014#include <image.h>
15#include <nand.h>
16#include <sata.h>
17#include <spi.h>
18#include <spi_flash.h>
19#include <splash.h>
20#include <usb.h>
Igor Grinbergf4a40f02014-11-03 11:32:20 +020021
22DECLARE_GLOBAL_DATA_PTR;
23
Nikita Kiryanov7e8d7f22015-01-14 10:42:52 +020024#ifdef CONFIG_SPI_FLASH
25static struct spi_flash *sf;
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020026static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
Nikita Kiryanov7e8d7f22015-01-14 10:42:52 +020027{
28 if (!sf) {
29 sf = spi_flash_probe(CONFIG_SF_DEFAULT_BUS,
30 CONFIG_SF_DEFAULT_CS,
31 CONFIG_SF_DEFAULT_SPEED,
32 CONFIG_SF_DEFAULT_MODE);
33 if (!sf)
34 return -ENODEV;
35 }
36
37 return spi_flash_read(sf, offset, read_size, (void *)bmp_load_addr);
38}
39#else
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020040static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
Nikita Kiryanov7e8d7f22015-01-14 10:42:52 +020041{
42 debug("%s: sf support not available\n", __func__);
43 return -ENOSYS;
44}
45#endif
46
Igor Grinbergf4a40f02014-11-03 11:32:20 +020047#ifdef CONFIG_CMD_NAND
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020048static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020049{
Grygorii Strashkoedba8cc2017-06-26 19:12:56 -050050 struct mtd_info *mtd = get_nand_dev_by_index(nand_curr_device);
51 return nand_read_skip_bad(mtd, offset,
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020052 &read_size, NULL,
Grygorii Strashkoedba8cc2017-06-26 19:12:56 -050053 mtd->size,
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020054 (u_char *)bmp_load_addr);
55}
56#else
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020057static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020058{
59 debug("%s: nand support not available\n", __func__);
60 return -ENOSYS;
61}
62#endif
63
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020064static int splash_storage_read_raw(struct splash_location *location,
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +020065 u32 bmp_load_addr, size_t read_size)
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020066{
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +020067 u32 offset;
68
69 if (!location)
70 return -EINVAL;
71
72 offset = location->offset;
73 switch (location->storage) {
74 case SPLASH_STORAGE_NAND:
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020075 return splash_nand_read_raw(bmp_load_addr, offset, read_size);
Nikita Kiryanov7e8d7f22015-01-14 10:42:52 +020076 case SPLASH_STORAGE_SF:
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020077 return splash_sf_read_raw(bmp_load_addr, offset, read_size);
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +020078 default:
79 printf("Unknown splash location\n");
80 }
81
82 return -EINVAL;
Nikita Kiryanov7be4cd22015-01-14 10:42:50 +020083}
84
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +020085static int splash_load_raw(struct splash_location *location, u32 bmp_load_addr)
Igor Grinbergf4a40f02014-11-03 11:32:20 +020086{
87 struct bmp_header *bmp_hdr;
88 int res;
89 size_t bmp_size, bmp_header_size = sizeof(struct bmp_header);
90
91 if (bmp_load_addr + bmp_header_size >= gd->start_addr_sp)
92 goto splash_address_too_high;
93
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +020094 res = splash_storage_read_raw(location, bmp_load_addr, bmp_header_size);
Igor Grinbergf4a40f02014-11-03 11:32:20 +020095 if (res < 0)
96 return res;
97
98 bmp_hdr = (struct bmp_header *)bmp_load_addr;
99 bmp_size = le32_to_cpu(bmp_hdr->file_size);
100
101 if (bmp_load_addr + bmp_size >= gd->start_addr_sp)
102 goto splash_address_too_high;
103
Nikita Kiryanovbcbb6442015-10-29 11:54:40 +0200104 return splash_storage_read_raw(location, bmp_load_addr, bmp_size);
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200105
106splash_address_too_high:
Nikita Kiryanovf82eb2f2015-01-14 10:42:54 +0200107 printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200108
Nikita Kiryanov6947e3f2015-01-14 10:42:49 +0200109 return -EFAULT;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200110}
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200111
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200112static int splash_select_fs_dev(struct splash_location *location)
113{
114 int res;
115
116 switch (location->storage) {
117 case SPLASH_STORAGE_MMC:
118 res = fs_set_blk_dev("mmc", location->devpart, FS_TYPE_ANY);
119 break;
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200120 case SPLASH_STORAGE_USB:
121 res = fs_set_blk_dev("usb", location->devpart, FS_TYPE_ANY);
122 break;
Nikita Kiryanov50c2d2e2015-10-29 11:54:43 +0200123 case SPLASH_STORAGE_SATA:
124 res = fs_set_blk_dev("sata", location->devpart, FS_TYPE_ANY);
125 break;
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300126 case SPLASH_STORAGE_NAND:
127 if (location->ubivol != NULL)
128 res = fs_set_blk_dev("ubi", NULL, FS_TYPE_UBIFS);
129 else
130 res = -ENODEV;
131 break;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200132 default:
133 printf("Error: unsupported location storage.\n");
134 return -ENODEV;
135 }
136
137 if (res)
138 printf("Error: could not access storage.\n");
139
140 return res;
141}
142
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200143#ifdef CONFIG_USB_STORAGE
144static int splash_init_usb(void)
145{
146 int err;
147
148 err = usb_init();
149 if (err)
150 return err;
151
Alexey Brodkind7b60fb2016-07-01 22:47:36 +0300152#ifndef CONFIG_DM_USB
153 err = usb_stor_scan(1) < 0 ? -ENODEV : 0;
154#endif
155
156 return err;
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200157}
158#else
159static inline int splash_init_usb(void)
160{
161 printf("Cannot load splash image: no USB support\n");
162 return -ENOSYS;
163}
164#endif
165
Simon Glass10e40d52017-06-14 21:28:25 -0600166#ifdef CONFIG_SATA
Nikita Kiryanov50c2d2e2015-10-29 11:54:43 +0200167static int splash_init_sata(void)
168{
169 return sata_initialize();
170}
171#else
172static inline int splash_init_sata(void)
173{
174 printf("Cannot load splash image: no SATA support\n");
175 return -ENOSYS;
176}
177#endif
178
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300179#ifdef CONFIG_CMD_UBIFS
180static int splash_mount_ubifs(struct splash_location *location)
181{
182 int res;
183 char cmd[32];
184
185 sprintf(cmd, "ubi part %s", location->mtdpart);
186 res = run_command(cmd, 0);
187 if (res)
188 return res;
189
190 sprintf(cmd, "ubifsmount %s", location->ubivol);
191 res = run_command(cmd, 0);
192
193 return res;
194}
195
196static inline int splash_umount_ubifs(void)
197{
198 return run_command("ubifsumount", 0);
199}
200#else
201static inline int splash_mount_ubifs(struct splash_location *location)
202{
203 printf("Cannot load splash image: no UBIFS support\n");
204 return -ENOSYS;
205}
206
207static inline int splash_umount_ubifs(void)
208{
209 printf("Cannot unmount UBIFS: no UBIFS support\n");
210 return -ENOSYS;
211}
212#endif
213
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200214#define SPLASH_SOURCE_DEFAULT_FILE_NAME "splash.bmp"
215
216static int splash_load_fs(struct splash_location *location, u32 bmp_load_addr)
217{
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200218 int res = 0;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200219 loff_t bmp_size;
Jonathan Golder3cc6e702017-02-24 17:46:10 +0100220 loff_t actread;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200221 char *splash_file;
222
223 splash_file = getenv("splashfile");
224 if (!splash_file)
225 splash_file = SPLASH_SOURCE_DEFAULT_FILE_NAME;
226
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200227 if (location->storage == SPLASH_STORAGE_USB)
228 res = splash_init_usb();
229
Nikita Kiryanov50c2d2e2015-10-29 11:54:43 +0200230 if (location->storage == SPLASH_STORAGE_SATA)
231 res = splash_init_sata();
232
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300233 if (location->ubivol != NULL)
234 res = splash_mount_ubifs(location);
235
Nikita Kiryanov9bb4e942015-10-29 11:54:42 +0200236 if (res)
237 return res;
238
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200239 res = splash_select_fs_dev(location);
240 if (res)
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300241 goto out;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200242
243 res = fs_size(splash_file, &bmp_size);
244 if (res) {
245 printf("Error (%d): cannot determine file size\n", res);
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300246 goto out;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200247 }
248
249 if (bmp_load_addr + bmp_size >= gd->start_addr_sp) {
250 printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300251 res = -EFAULT;
252 goto out;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200253 }
254
255 splash_select_fs_dev(location);
Jonathan Golder3cc6e702017-02-24 17:46:10 +0100256 res = fs_read(splash_file, bmp_load_addr, 0, 0, &actread);
Eran Matityahu1cb075c2016-06-07 10:38:37 +0300257
258out:
259 if (location->ubivol != NULL)
260 splash_umount_ubifs();
261
262 return res;
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200263}
264
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200265/**
266 * select_splash_location - return the splash location based on board support
267 * and env variable "splashsource".
268 *
269 * @locations: An array of supported splash locations.
270 * @size: Size of splash_locations array.
271 *
272 * @return: If a null set of splash locations is given, or
273 * splashsource env variable is set to unsupported value
274 * return NULL.
275 * If splashsource env variable is not defined
276 * return the first entry in splash_locations as default.
277 * If splashsource env variable contains a supported value
278 * return the location selected by splashsource.
279 */
280static struct splash_location *select_splash_location(
281 struct splash_location *locations, uint size)
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200282{
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200283 int i;
284 char *env_splashsource;
285
286 if (!locations || size == 0)
287 return NULL;
288
289 env_splashsource = getenv("splashsource");
290 if (env_splashsource == NULL)
291 return &locations[0];
292
293 for (i = 0; i < size; i++) {
294 if (!strcmp(locations[i].name, env_splashsource))
295 return &locations[i];
296 }
297
298 printf("splashsource env variable set to unsupported value\n");
299 return NULL;
300}
301
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200302#ifdef CONFIG_FIT
303static int splash_load_fit(struct splash_location *location, u32 bmp_load_addr)
304{
305 int res;
306 int node_offset;
307 int splash_offset;
308 int splash_size;
309 struct image_header *img_header;
310 const u32 *fit_header;
311 u32 fit_size;
312 const size_t header_size = sizeof(struct image_header);
313
314 /* Read in image header */
315 res = splash_storage_read_raw(location, bmp_load_addr, header_size);
316 if (res < 0)
317 return res;
318
319 img_header = (struct image_header *)bmp_load_addr;
320 fit_size = fdt_totalsize(img_header);
321
322 /* Read in entire FIT */
323 fit_header = (const u32 *)(bmp_load_addr + header_size);
324 res = splash_storage_read_raw(location, (u32)fit_header, fit_size);
325 if (res < 0)
326 return res;
327
328 res = fit_check_format(fit_header);
329 if (!res) {
330 debug("Could not find valid FIT image\n");
331 return -EINVAL;
332 }
333
334 node_offset = fit_image_get_node(fit_header, location->name);
335 if (node_offset < 0) {
336 debug("Could not find splash image '%s' in FIT\n",
337 location->name);
338 return -ENOENT;
339 }
340
341 res = fit_image_get_data_offset(fit_header, node_offset,
342 &splash_offset);
343 if (res < 0) {
344 printf("Failed to load splash image (err=%d)\n", res);
345 return res;
346 }
347
348 res = fit_image_get_data_size(fit_header, node_offset, &splash_size);
349 if (res < 0) {
350 printf("Failed to load splash image (err=%d)\n", res);
351 return res;
352 }
353
354 /* Align data offset to 4-byte boundrary */
355 fit_size = fdt_totalsize(fit_header);
356 fit_size = (fit_size + 3) & ~3;
357
358 /* Read in the splash data */
359 location->offset = (location->offset + fit_size + splash_offset);
360 res = splash_storage_read_raw(location, bmp_load_addr , splash_size);
361 if (res < 0)
362 return res;
363
364 return 0;
365}
366#endif /* CONFIG_FIT */
367
Nikita Kiryanovf82eb2f2015-01-14 10:42:54 +0200368/**
369 * splash_source_load - load splash image from a supported location.
370 *
371 * Select a splash image location based on the value of splashsource environment
372 * variable and the board supported splash source locations, and load a
373 * splashimage to the address pointed to by splashimage environment variable.
374 *
375 * @locations: An array of supported splash locations.
376 * @size: Size of splash_locations array.
377 *
378 * @return: 0 on success, negative value on failure.
379 */
380int splash_source_load(struct splash_location *locations, uint size)
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200381{
382 struct splash_location *splash_location;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200383 char *env_splashimage_value;
384 u32 bmp_load_addr;
385
386 env_splashimage_value = getenv("splashimage");
387 if (env_splashimage_value == NULL)
Nikita Kiryanov6947e3f2015-01-14 10:42:49 +0200388 return -ENOENT;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200389
390 bmp_load_addr = simple_strtoul(env_splashimage_value, 0, 16);
391 if (bmp_load_addr == 0) {
392 printf("Error: bad splashimage address specified\n");
Nikita Kiryanov6947e3f2015-01-14 10:42:49 +0200393 return -EFAULT;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200394 }
395
Nikita Kiryanovfd29dd52015-01-14 10:42:51 +0200396 splash_location = select_splash_location(locations, size);
397 if (!splash_location)
398 return -EINVAL;
399
tomas.melin@vaisala.com3b593f92016-11-16 13:02:32 +0200400 if (splash_location->flags == SPLASH_STORAGE_RAW)
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200401 return splash_load_raw(splash_location, bmp_load_addr);
tomas.melin@vaisala.com3b593f92016-11-16 13:02:32 +0200402 else if (splash_location->flags == SPLASH_STORAGE_FS)
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200403 return splash_load_fs(splash_location, bmp_load_addr);
tomas.melin@vaisala.comdb1b79b2017-01-13 13:20:14 +0200404#ifdef CONFIG_FIT
405 else if (splash_location->flags == SPLASH_STORAGE_FIT)
406 return splash_load_fit(splash_location, bmp_load_addr);
407#endif
Nikita Kiryanov870dd302015-10-29 11:54:41 +0200408 return -EINVAL;
Igor Grinbergf4a40f02014-11-03 11:32:20 +0200409}