xref: /openbmc/u-boot/common/splash_source.c (revision 9702ec00)
1 /*
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>
10 #include <nand.h>
11 #include <errno.h>
12 #include <splash.h>
13 #include <spi_flash.h>
14 #include <spi.h>
15 #include <usb.h>
16 #include <sata.h>
17 #include <bmp_layout.h>
18 #include <fs.h>
19 
20 DECLARE_GLOBAL_DATA_PTR;
21 
22 #ifdef CONFIG_SPI_FLASH
23 static struct spi_flash *sf;
24 static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
25 {
26 	if (!sf) {
27 		sf = spi_flash_probe(CONFIG_SF_DEFAULT_BUS,
28 				     CONFIG_SF_DEFAULT_CS,
29 				     CONFIG_SF_DEFAULT_SPEED,
30 				     CONFIG_SF_DEFAULT_MODE);
31 		if (!sf)
32 			return -ENODEV;
33 	}
34 
35 	return spi_flash_read(sf, offset, read_size, (void *)bmp_load_addr);
36 }
37 #else
38 static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
39 {
40 	debug("%s: sf support not available\n", __func__);
41 	return -ENOSYS;
42 }
43 #endif
44 
45 #ifdef CONFIG_CMD_NAND
46 static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
47 {
48 	return nand_read_skip_bad(nand_info[nand_curr_device], offset,
49 				  &read_size, NULL,
50 				  nand_info[nand_curr_device]->size,
51 				  (u_char *)bmp_load_addr);
52 }
53 #else
54 static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
55 {
56 	debug("%s: nand support not available\n", __func__);
57 	return -ENOSYS;
58 }
59 #endif
60 
61 static int splash_storage_read_raw(struct splash_location *location,
62 			       u32 bmp_load_addr, size_t read_size)
63 {
64 	u32 offset;
65 
66 	if (!location)
67 		return -EINVAL;
68 
69 	offset = location->offset;
70 	switch (location->storage) {
71 	case SPLASH_STORAGE_NAND:
72 		return splash_nand_read_raw(bmp_load_addr, offset, read_size);
73 	case SPLASH_STORAGE_SF:
74 		return splash_sf_read_raw(bmp_load_addr, offset, read_size);
75 	default:
76 		printf("Unknown splash location\n");
77 	}
78 
79 	return -EINVAL;
80 }
81 
82 static int splash_load_raw(struct splash_location *location, u32 bmp_load_addr)
83 {
84 	struct bmp_header *bmp_hdr;
85 	int res;
86 	size_t bmp_size, bmp_header_size = sizeof(struct bmp_header);
87 
88 	if (bmp_load_addr + bmp_header_size >= gd->start_addr_sp)
89 		goto splash_address_too_high;
90 
91 	res = splash_storage_read_raw(location, bmp_load_addr, bmp_header_size);
92 	if (res < 0)
93 		return res;
94 
95 	bmp_hdr = (struct bmp_header *)bmp_load_addr;
96 	bmp_size = le32_to_cpu(bmp_hdr->file_size);
97 
98 	if (bmp_load_addr + bmp_size >= gd->start_addr_sp)
99 		goto splash_address_too_high;
100 
101 	return splash_storage_read_raw(location, bmp_load_addr, bmp_size);
102 
103 splash_address_too_high:
104 	printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
105 
106 	return -EFAULT;
107 }
108 
109 static int splash_select_fs_dev(struct splash_location *location)
110 {
111 	int res;
112 
113 	switch (location->storage) {
114 	case SPLASH_STORAGE_MMC:
115 		res = fs_set_blk_dev("mmc", location->devpart, FS_TYPE_ANY);
116 		break;
117 	case SPLASH_STORAGE_USB:
118 		res = fs_set_blk_dev("usb", location->devpart, FS_TYPE_ANY);
119 		break;
120 	case SPLASH_STORAGE_SATA:
121 		res = fs_set_blk_dev("sata", location->devpart, FS_TYPE_ANY);
122 		break;
123 	default:
124 		printf("Error: unsupported location storage.\n");
125 		return -ENODEV;
126 	}
127 
128 	if (res)
129 		printf("Error: could not access storage.\n");
130 
131 	return res;
132 }
133 
134 #ifdef CONFIG_USB_STORAGE
135 static int splash_init_usb(void)
136 {
137 	int err;
138 
139 	err = usb_init();
140 	if (err)
141 		return err;
142 
143 	return usb_stor_scan(1) < 0 ? -ENODEV : 0;
144 }
145 #else
146 static inline int splash_init_usb(void)
147 {
148 	printf("Cannot load splash image: no USB support\n");
149 	return -ENOSYS;
150 }
151 #endif
152 
153 #ifdef CONFIG_CMD_SATA
154 static int splash_init_sata(void)
155 {
156 	return sata_initialize();
157 }
158 #else
159 static inline int splash_init_sata(void)
160 {
161 	printf("Cannot load splash image: no SATA support\n");
162 	return -ENOSYS;
163 }
164 #endif
165 
166 #define SPLASH_SOURCE_DEFAULT_FILE_NAME		"splash.bmp"
167 
168 static int splash_load_fs(struct splash_location *location, u32 bmp_load_addr)
169 {
170 	int res = 0;
171 	loff_t bmp_size;
172 	char *splash_file;
173 
174 	splash_file = getenv("splashfile");
175 	if (!splash_file)
176 		splash_file = SPLASH_SOURCE_DEFAULT_FILE_NAME;
177 
178 	if (location->storage == SPLASH_STORAGE_USB)
179 		res = splash_init_usb();
180 
181 	if (location->storage == SPLASH_STORAGE_SATA)
182 		res = splash_init_sata();
183 
184 	if (res)
185 		return res;
186 
187 	res = splash_select_fs_dev(location);
188 	if (res)
189 		return res;
190 
191 	res = fs_size(splash_file, &bmp_size);
192 	if (res) {
193 		printf("Error (%d): cannot determine file size\n", res);
194 		return res;
195 	}
196 
197 	if (bmp_load_addr + bmp_size >= gd->start_addr_sp) {
198 		printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
199 		return -EFAULT;
200 	}
201 
202 	splash_select_fs_dev(location);
203 	return fs_read(splash_file, bmp_load_addr, 0, 0, NULL);
204 }
205 
206 /**
207  * select_splash_location - return the splash location based on board support
208  *			    and env variable "splashsource".
209  *
210  * @locations:		An array of supported splash locations.
211  * @size:		Size of splash_locations array.
212  *
213  * @return: If a null set of splash locations is given, or
214  *	    splashsource env variable is set to unsupported value
215  *			return NULL.
216  *	    If splashsource env variable is not defined
217  *			return the first entry in splash_locations as default.
218  *	    If splashsource env variable contains a supported value
219  *			return the location selected by splashsource.
220  */
221 static struct splash_location *select_splash_location(
222 			    struct splash_location *locations, uint size)
223 {
224 	int i;
225 	char *env_splashsource;
226 
227 	if (!locations || size == 0)
228 		return NULL;
229 
230 	env_splashsource = getenv("splashsource");
231 	if (env_splashsource == NULL)
232 		return &locations[0];
233 
234 	for (i = 0; i < size; i++) {
235 		if (!strcmp(locations[i].name, env_splashsource))
236 			return &locations[i];
237 	}
238 
239 	printf("splashsource env variable set to unsupported value\n");
240 	return NULL;
241 }
242 
243 /**
244  * splash_source_load - load splash image from a supported location.
245  *
246  * Select a splash image location based on the value of splashsource environment
247  * variable and the board supported splash source locations, and load a
248  * splashimage to the address pointed to by splashimage environment variable.
249  *
250  * @locations:		An array of supported splash locations.
251  * @size:		Size of splash_locations array.
252  *
253  * @return: 0 on success, negative value on failure.
254  */
255 int splash_source_load(struct splash_location *locations, uint size)
256 {
257 	struct splash_location *splash_location;
258 	char *env_splashimage_value;
259 	u32 bmp_load_addr;
260 
261 	env_splashimage_value = getenv("splashimage");
262 	if (env_splashimage_value == NULL)
263 		return -ENOENT;
264 
265 	bmp_load_addr = simple_strtoul(env_splashimage_value, 0, 16);
266 	if (bmp_load_addr == 0) {
267 		printf("Error: bad splashimage address specified\n");
268 		return -EFAULT;
269 	}
270 
271 	splash_location = select_splash_location(locations, size);
272 	if (!splash_location)
273 		return -EINVAL;
274 
275 	if (splash_location->flags & SPLASH_STORAGE_RAW)
276 		return splash_load_raw(splash_location, bmp_load_addr);
277 	else if (splash_location->flags & SPLASH_STORAGE_FS)
278 		return splash_load_fs(splash_location, bmp_load_addr);
279 
280 	return -EINVAL;
281 }
282