xref: /openbmc/u-boot/common/spl/spl_fit.c (revision 510e379c)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2016 Google, Inc
4  * Written by Simon Glass <sjg@chromium.org>
5  */
6 
7 #include <common.h>
8 #include <errno.h>
9 #include <image.h>
10 #include <linux/libfdt.h>
11 #include <spl.h>
12 
13 #ifndef CONFIG_SYS_BOOTM_LEN
14 #define CONFIG_SYS_BOOTM_LEN	(64 << 20)
15 #endif
16 
17 /**
18  * spl_fit_get_image_name(): By using the matching configuration subnode,
19  * retrieve the name of an image, specified by a property name and an index
20  * into that.
21  * @fit:	Pointer to the FDT blob.
22  * @images:	Offset of the /images subnode.
23  * @type:	Name of the property within the configuration subnode.
24  * @index:	Index into the list of strings in this property.
25  * @outname:	Name of the image
26  *
27  * Return:	0 on success, or a negative error number
28  */
29 static int spl_fit_get_image_name(const void *fit, int images,
30 				  const char *type, int index,
31 				  char **outname)
32 {
33 	const char *name, *str;
34 	__maybe_unused int node;
35 	int conf_node;
36 	int len, i;
37 
38 	conf_node = fit_find_config_node(fit);
39 	if (conf_node < 0) {
40 #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
41 		printf("No matching DT out of these options:\n");
42 		for (node = fdt_first_subnode(fit, conf_node);
43 		     node >= 0;
44 		     node = fdt_next_subnode(fit, node)) {
45 			name = fdt_getprop(fit, node, "description", &len);
46 			printf("   %s\n", name);
47 		}
48 #endif
49 		return conf_node;
50 	}
51 
52 	name = fdt_getprop(fit, conf_node, type, &len);
53 	if (!name) {
54 		debug("cannot find property '%s': %d\n", type, len);
55 		return -EINVAL;
56 	}
57 
58 	str = name;
59 	for (i = 0; i < index; i++) {
60 		str = strchr(str, '\0') + 1;
61 		if (!str || (str - name >= len)) {
62 			debug("no string for index %d\n", index);
63 			return -E2BIG;
64 		}
65 	}
66 
67 	*outname = (char *)str;
68 	return 0;
69 }
70 
71 /**
72  * spl_fit_get_image_node(): By using the matching configuration subnode,
73  * retrieve the name of an image, specified by a property name and an index
74  * into that.
75  * @fit:	Pointer to the FDT blob.
76  * @images:	Offset of the /images subnode.
77  * @type:	Name of the property within the configuration subnode.
78  * @index:	Index into the list of strings in this property.
79  *
80  * Return:	the node offset of the respective image node or a negative
81  *		error number.
82  */
83 static int spl_fit_get_image_node(const void *fit, int images,
84 				  const char *type, int index)
85 {
86 	char *str;
87 	int err;
88 	int node;
89 
90 	err = spl_fit_get_image_name(fit, images, type, index, &str);
91 	if (err)
92 		return err;
93 
94 	debug("%s: '%s'\n", type, str);
95 
96 	node = fdt_subnode_offset(fit, images, str);
97 	if (node < 0) {
98 		debug("cannot find image node '%s': %d\n", str, node);
99 		return -EINVAL;
100 	}
101 
102 	return node;
103 }
104 
105 static int get_aligned_image_offset(struct spl_load_info *info, int offset)
106 {
107 	/*
108 	 * If it is a FS read, get the first address before offset which is
109 	 * aligned to ARCH_DMA_MINALIGN. If it is raw read return the
110 	 * block number to which offset belongs.
111 	 */
112 	if (info->filename)
113 		return offset & ~(ARCH_DMA_MINALIGN - 1);
114 
115 	return offset / info->bl_len;
116 }
117 
118 static int get_aligned_image_overhead(struct spl_load_info *info, int offset)
119 {
120 	/*
121 	 * If it is a FS read, get the difference between the offset and
122 	 * the first address before offset which is aligned to
123 	 * ARCH_DMA_MINALIGN. If it is raw read return the offset within the
124 	 * block.
125 	 */
126 	if (info->filename)
127 		return offset & (ARCH_DMA_MINALIGN - 1);
128 
129 	return offset % info->bl_len;
130 }
131 
132 static int get_aligned_image_size(struct spl_load_info *info, int data_size,
133 				  int offset)
134 {
135 	data_size = data_size + get_aligned_image_overhead(info, offset);
136 
137 	if (info->filename)
138 		return data_size;
139 
140 	return (data_size + info->bl_len - 1) / info->bl_len;
141 }
142 
143 #ifdef CONFIG_SPL_FPGA_SUPPORT
144 __weak int spl_load_fpga_image(struct spl_load_info *info, size_t length,
145 			       int nr_sectors, int sector_offset)
146 {
147 	return 0;
148 }
149 #endif
150 
151 /**
152  * spl_load_fit_image(): load the image described in a certain FIT node
153  * @info:	points to information about the device to load data from
154  * @sector:	the start sector of the FIT image on the device
155  * @fit:	points to the flattened device tree blob describing the FIT
156  *		image
157  * @base_offset: the beginning of the data area containing the actual
158  *		image data, relative to the beginning of the FIT
159  * @node:	offset of the DT node describing the image to load (relative
160  *		to @fit)
161  * @image_info:	will be filled with information about the loaded image
162  *		If the FIT node does not contain a "load" (address) property,
163  *		the image gets loaded to the address pointed to by the
164  *		load_addr member in this struct.
165  *
166  * Return:	0 on success or a negative error number.
167  */
168 static int spl_load_fit_image(struct spl_load_info *info, ulong sector,
169 			      void *fit, ulong base_offset, int node,
170 			      struct spl_image_info *image_info)
171 {
172 	int offset, sector_offset;
173 	size_t length;
174 	int len;
175 	ulong size;
176 	ulong load_addr, load_ptr;
177 	void *src;
178 	ulong overhead;
179 	int nr_sectors;
180 	int align_len = ARCH_DMA_MINALIGN - 1;
181 	uint8_t image_comp = -1, type = -1;
182 	const void *data;
183 	bool external_data = false;
184 
185 	if (IS_ENABLED(CONFIG_SPL_FPGA_SUPPORT) ||
186 	    (IS_ENABLED(CONFIG_SPL_OS_BOOT) && IS_ENABLED(CONFIG_SPL_GZIP))) {
187 		if (fit_image_get_type(fit, node, &type))
188 			puts("Cannot get image type.\n");
189 		else
190 			debug("%s ", genimg_get_type_name(type));
191 	}
192 
193 	if (IS_ENABLED(CONFIG_SPL_OS_BOOT) && IS_ENABLED(CONFIG_SPL_GZIP)) {
194 		if (fit_image_get_comp(fit, node, &image_comp))
195 			puts("Cannot get image compression format.\n");
196 		else
197 			debug("%s ", genimg_get_comp_name(image_comp));
198 	}
199 
200 	if (fit_image_get_load(fit, node, &load_addr))
201 		load_addr = image_info->load_addr;
202 
203 	if (!fit_image_get_data_position(fit, node, &offset)) {
204 		external_data = true;
205 	} else if (!fit_image_get_data_offset(fit, node, &offset)) {
206 		offset += base_offset;
207 		external_data = true;
208 	}
209 
210 	if (external_data) {
211 		/* External data */
212 		if (fit_image_get_data_size(fit, node, &len))
213 			return -ENOENT;
214 
215 		load_ptr = (load_addr + align_len) & ~align_len;
216 		length = len;
217 
218 		overhead = get_aligned_image_overhead(info, offset);
219 		nr_sectors = get_aligned_image_size(info, length, offset);
220 		sector_offset = sector + get_aligned_image_offset(info, offset);
221 
222 #ifdef CONFIG_SPL_FPGA_SUPPORT
223 		if (type == IH_TYPE_FPGA) {
224 			return spl_load_fpga_image(info, length, nr_sectors,
225 						   sector_offset);
226 		}
227 #endif
228 
229 		if (info->read(info, sector_offset,
230 			       nr_sectors, (void *)load_ptr) != nr_sectors)
231 			return -EIO;
232 
233 		debug("External data: dst=%lx, offset=%x, size=%lx\n",
234 		      load_ptr, offset, (unsigned long)length);
235 		src = (void *)load_ptr + overhead;
236 	} else {
237 		/* Embedded data */
238 		if (fit_image_get_data(fit, node, &data, &length)) {
239 			puts("Cannot get image data/size\n");
240 			return -ENOENT;
241 		}
242 		debug("Embedded data: dst=%lx, size=%lx\n", load_addr,
243 		      (unsigned long)length);
244 		src = (void *)data;
245 	}
246 
247 #ifdef CONFIG_SPL_FIT_SIGNATURE
248 	printf("## Checking hash(es) for Image %s ... ",
249 	       fit_get_name(fit, node, NULL));
250 	if (!fit_image_verify_with_data(fit, node,
251 					 src, length))
252 		return -EPERM;
253 	puts("OK\n");
254 #endif
255 
256 #ifdef CONFIG_SPL_FIT_IMAGE_POST_PROCESS
257 	board_fit_image_post_process(&src, &length);
258 #endif
259 
260 	if (IS_ENABLED(CONFIG_SPL_GZIP) && image_comp == IH_COMP_GZIP) {
261 		size = length;
262 		if (gunzip((void *)load_addr, CONFIG_SYS_BOOTM_LEN,
263 			   src, &size)) {
264 			puts("Uncompressing error\n");
265 			return -EIO;
266 		}
267 		length = size;
268 	} else {
269 		memcpy((void *)load_addr, src, length);
270 	}
271 
272 	if (image_info) {
273 		image_info->load_addr = load_addr;
274 		image_info->size = length;
275 		image_info->entry_point = fdt_getprop_u32(fit, node, "entry");
276 	}
277 
278 	return 0;
279 }
280 
281 static int spl_fit_append_fdt(struct spl_image_info *spl_image,
282 			      struct spl_load_info *info, ulong sector,
283 			      void *fit, int images, ulong base_offset)
284 {
285 	struct spl_image_info image_info;
286 	int node, ret;
287 
288 	/* Figure out which device tree the board wants to use */
289 	node = spl_fit_get_image_node(fit, images, FIT_FDT_PROP, 0);
290 	if (node < 0) {
291 		debug("%s: cannot find FDT node\n", __func__);
292 		return node;
293 	}
294 
295 	/*
296 	 * Read the device tree and place it after the image.
297 	 * Align the destination address to ARCH_DMA_MINALIGN.
298 	 */
299 	image_info.load_addr = spl_image->load_addr + spl_image->size;
300 	ret = spl_load_fit_image(info, sector, fit, base_offset, node,
301 				 &image_info);
302 
303 	if (ret < 0)
304 		return ret;
305 
306 	/* Make the load-address of the FDT available for the SPL framework */
307 	spl_image->fdt_addr = (void *)image_info.load_addr;
308 #if !CONFIG_IS_ENABLED(FIT_IMAGE_TINY)
309 	/* Try to make space, so we can inject details on the loadables */
310 	ret = fdt_shrink_to_minimum(spl_image->fdt_addr, 8192);
311 #endif
312 
313 	return ret;
314 }
315 
316 static int spl_fit_record_loadable(const void *fit, int images, int index,
317 				   void *blob, struct spl_image_info *image)
318 {
319 	int ret = 0;
320 #if !CONFIG_IS_ENABLED(FIT_IMAGE_TINY)
321 	char *name;
322 	int node;
323 
324 	ret = spl_fit_get_image_name(fit, images, "loadables",
325 				     index, &name);
326 	if (ret < 0)
327 		return ret;
328 
329 	node = spl_fit_get_image_node(fit, images, "loadables", index);
330 
331 	ret = fdt_record_loadable(blob, index, name, image->load_addr,
332 				  image->size, image->entry_point,
333 				  fdt_getprop(fit, node, "type", NULL),
334 				  fdt_getprop(fit, node, "os", NULL));
335 #endif
336 	return ret;
337 }
338 
339 static int spl_fit_image_get_os(const void *fit, int noffset, uint8_t *os)
340 {
341 #if CONFIG_IS_ENABLED(FIT_IMAGE_TINY)
342 	return -ENOTSUPP;
343 #else
344 	return fit_image_get_os(fit, noffset, os);
345 #endif
346 }
347 
348 int spl_load_simple_fit(struct spl_image_info *spl_image,
349 			struct spl_load_info *info, ulong sector, void *fit)
350 {
351 	int sectors;
352 	ulong size;
353 	unsigned long count;
354 	struct spl_image_info image_info;
355 	int node = -1;
356 	int images, ret;
357 	int base_offset, hsize, align_len = ARCH_DMA_MINALIGN - 1;
358 	int index = 0;
359 
360 	/*
361 	 * For FIT with external data, figure out where the external images
362 	 * start. This is the base for the data-offset properties in each
363 	 * image.
364 	 */
365 	size = fdt_totalsize(fit);
366 	size = (size + 3) & ~3;
367 	base_offset = (size + 3) & ~3;
368 
369 	/*
370 	 * So far we only have one block of data from the FIT. Read the entire
371 	 * thing, including that first block, placing it so it finishes before
372 	 * where we will load the image.
373 	 *
374 	 * Note that we will load the image such that its first byte will be
375 	 * at the load address. Since that byte may be part-way through a
376 	 * block, we may load the image up to one block before the load
377 	 * address. So take account of that here by subtracting an addition
378 	 * block length from the FIT start position.
379 	 *
380 	 * In fact the FIT has its own load address, but we assume it cannot
381 	 * be before CONFIG_SYS_TEXT_BASE.
382 	 *
383 	 * For FIT with data embedded, data is loaded as part of FIT image.
384 	 * For FIT with external data, data is not loaded in this step.
385 	 */
386 	hsize = (size + info->bl_len + align_len) & ~align_len;
387 	fit = spl_get_load_buffer(-hsize, hsize);
388 	sectors = get_aligned_image_size(info, size, 0);
389 	count = info->read(info, sector, sectors, fit);
390 	debug("fit read sector %lx, sectors=%d, dst=%p, count=%lu\n",
391 	      sector, sectors, fit, count);
392 	if (count == 0)
393 		return -EIO;
394 
395 	/* find the node holding the images information */
396 	images = fdt_path_offset(fit, FIT_IMAGES_PATH);
397 	if (images < 0) {
398 		debug("%s: Cannot find /images node: %d\n", __func__, images);
399 		return -1;
400 	}
401 
402 #ifdef CONFIG_SPL_FPGA_SUPPORT
403 	node = spl_fit_get_image_node(fit, images, "fpga", 0);
404 	if (node >= 0) {
405 		/* Load the image and set up the spl_image structure */
406 		ret = spl_load_fit_image(info, sector, fit, base_offset, node,
407 					 spl_image);
408 		if (ret) {
409 			printf("%s: Cannot load the FPGA: %i\n", __func__, ret);
410 			return ret;
411 		}
412 		puts("FPGA image loaded from FIT\n");
413 		node = -1;
414 	}
415 #endif
416 
417 	/*
418 	 * Find the U-Boot image using the following search order:
419 	 *   - start at 'firmware' (e.g. an ARM Trusted Firmware)
420 	 *   - fall back 'kernel' (e.g. a Falcon-mode OS boot
421 	 *   - fall back to using the first 'loadables' entry
422 	 */
423 	if (node < 0)
424 		node = spl_fit_get_image_node(fit, images, FIT_FIRMWARE_PROP,
425 					      0);
426 #ifdef CONFIG_SPL_OS_BOOT
427 	if (node < 0)
428 		node = spl_fit_get_image_node(fit, images, FIT_KERNEL_PROP, 0);
429 #endif
430 	if (node < 0) {
431 		debug("could not find firmware image, trying loadables...\n");
432 		node = spl_fit_get_image_node(fit, images, "loadables", 0);
433 		/*
434 		 * If we pick the U-Boot image from "loadables", start at
435 		 * the second image when later loading additional images.
436 		 */
437 		index = 1;
438 	}
439 	if (node < 0) {
440 		debug("%s: Cannot find u-boot image node: %d\n",
441 		      __func__, node);
442 		return -1;
443 	}
444 
445 	/* Load the image and set up the spl_image structure */
446 	ret = spl_load_fit_image(info, sector, fit, base_offset, node,
447 				 spl_image);
448 	if (ret)
449 		return ret;
450 
451 	/*
452 	 * For backward compatibility, we treat the first node that is
453 	 * as a U-Boot image, if no OS-type has been declared.
454 	 */
455 	if (!spl_fit_image_get_os(fit, node, &spl_image->os))
456 		debug("Image OS is %s\n", genimg_get_os_name(spl_image->os));
457 #if !defined(CONFIG_SPL_OS_BOOT)
458 	else
459 		spl_image->os = IH_OS_U_BOOT;
460 #endif
461 
462 	/*
463 	 * Booting a next-stage U-Boot may require us to append the FDT.
464 	 * We allow this to fail, as the U-Boot image might embed its FDT.
465 	 */
466 	if (spl_image->os == IH_OS_U_BOOT)
467 		spl_fit_append_fdt(spl_image, info, sector, fit,
468 				   images, base_offset);
469 
470 	/* Now check if there are more images for us to load */
471 	for (; ; index++) {
472 		uint8_t os_type = IH_OS_INVALID;
473 
474 		node = spl_fit_get_image_node(fit, images, "loadables", index);
475 		if (node < 0)
476 			break;
477 
478 		ret = spl_load_fit_image(info, sector, fit, base_offset, node,
479 					 &image_info);
480 		if (ret < 0)
481 			continue;
482 
483 		if (!spl_fit_image_get_os(fit, node, &os_type))
484 			debug("Loadable is %s\n", genimg_get_os_name(os_type));
485 
486 		if (os_type == IH_OS_U_BOOT) {
487 			spl_fit_append_fdt(&image_info, info, sector,
488 					   fit, images, base_offset);
489 			spl_image->fdt_addr = image_info.fdt_addr;
490 		}
491 
492 		/*
493 		 * If the "firmware" image did not provide an entry point,
494 		 * use the first valid entry point from the loadables.
495 		 */
496 		if (spl_image->entry_point == FDT_ERROR &&
497 		    image_info.entry_point != FDT_ERROR)
498 			spl_image->entry_point = image_info.entry_point;
499 
500 		/* Record our loadables into the FDT */
501 		if (spl_image->fdt_addr)
502 			spl_fit_record_loadable(fit, images, index,
503 						spl_image->fdt_addr,
504 						&image_info);
505 	}
506 
507 	/*
508 	 * If a platform does not provide CONFIG_SYS_UBOOT_START, U-Boot's
509 	 * Makefile will set it to 0 and it will end up as the entry point
510 	 * here. What it actually means is: use the load address.
511 	 */
512 	if (spl_image->entry_point == FDT_ERROR || spl_image->entry_point == 0)
513 		spl_image->entry_point = spl_image->load_addr;
514 
515 	return 0;
516 }
517