xref: /openbmc/u-boot/cmd/bootefi.c (revision 9ed00b07)
1 /*
2  *  EFI application loader
3  *
4  *  Copyright (c) 2016 Alexander Graf
5  *
6  *  SPDX-License-Identifier:     GPL-2.0+
7  */
8 
9 #include <common.h>
10 #include <command.h>
11 #include <dm/device.h>
12 #include <efi_loader.h>
13 #include <errno.h>
14 #include <libfdt.h>
15 #include <libfdt_env.h>
16 #include <memalign.h>
17 #include <asm/global_data.h>
18 
19 DECLARE_GLOBAL_DATA_PTR;
20 
21 /*
22  * When booting using the "bootefi" command, we don't know which
23  * physical device the file came from. So we create a pseudo-device
24  * called "bootefi" with the device path /bootefi.
25  *
26  * In addition to the originating device we also declare the file path
27  * of "bootefi" based loads to be /bootefi.
28  */
29 static struct efi_device_path_file_path bootefi_image_path[] = {
30 	{
31 		.dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE,
32 		.dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH,
33 		.dp.length = sizeof(bootefi_image_path[0]),
34 		.str = { 'b','o','o','t','e','f','i' },
35 	}, {
36 		.dp.type = DEVICE_PATH_TYPE_END,
37 		.dp.sub_type = DEVICE_PATH_SUB_TYPE_END,
38 		.dp.length = sizeof(bootefi_image_path[0]),
39 	}
40 };
41 
42 static struct efi_device_path_file_path bootefi_device_path[] = {
43 	{
44 		.dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE,
45 		.dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH,
46 		.dp.length = sizeof(bootefi_image_path[0]),
47 		.str = { 'b','o','o','t','e','f','i' },
48 	}, {
49 		.dp.type = DEVICE_PATH_TYPE_END,
50 		.dp.sub_type = DEVICE_PATH_SUB_TYPE_END,
51 		.dp.length = sizeof(bootefi_image_path[0]),
52 	}
53 };
54 
55 static efi_status_t bootefi_open_dp(void *handle, efi_guid_t *protocol,
56 			void **protocol_interface, void *agent_handle,
57 			void *controller_handle, uint32_t attributes)
58 {
59 	*protocol_interface = bootefi_device_path;
60 	return EFI_SUCCESS;
61 }
62 
63 /* The EFI loaded_image interface for the image executed via "bootefi" */
64 static struct efi_loaded_image loaded_image_info = {
65 	.device_handle = bootefi_device_path,
66 	.file_path = bootefi_image_path,
67 };
68 
69 /* The EFI object struct for the image executed via "bootefi" */
70 static struct efi_object loaded_image_info_obj = {
71 	.handle = &loaded_image_info,
72 	.protocols = {
73 		{
74 			/*
75 			 * When asking for the loaded_image interface, just
76 			 * return handle which points to loaded_image_info
77 			 */
78 			.guid = &efi_guid_loaded_image,
79 			.open = &efi_return_handle,
80 		},
81 		{
82 			/*
83 			 * When asking for the device path interface, return
84 			 * bootefi_device_path
85 			 */
86 			.guid = &efi_guid_device_path,
87 			.open = &bootefi_open_dp,
88 		},
89 	},
90 };
91 
92 /* The EFI object struct for the device the "bootefi" image was loaded from */
93 static struct efi_object bootefi_device_obj = {
94 	.handle = bootefi_device_path,
95 	.protocols = {
96 		{
97 			/* When asking for the device path interface, return
98 			 * bootefi_device_path */
99 			.guid = &efi_guid_device_path,
100 			.open = &bootefi_open_dp,
101 		}
102 	},
103 };
104 
105 static void *copy_fdt(void *fdt)
106 {
107 	u64 fdt_size = fdt_totalsize(fdt);
108 	unsigned long fdt_ram_start = -1L, fdt_pages;
109 	u64 new_fdt_addr;
110 	void *new_fdt;
111 	int i;
112 
113         for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
114                 u64 ram_start = gd->bd->bi_dram[i].start;
115                 u64 ram_size = gd->bd->bi_dram[i].size;
116 
117 		if (!ram_size)
118 			continue;
119 
120 		if (ram_start < fdt_ram_start)
121 			fdt_ram_start = ram_start;
122 	}
123 
124 	/* Give us at least 4kb breathing room */
125 	fdt_size = ALIGN(fdt_size + 4096, 4096);
126 	fdt_pages = fdt_size >> EFI_PAGE_SHIFT;
127 
128 	/* Safe fdt location is at 128MB */
129 	new_fdt_addr = fdt_ram_start + (128 * 1024 * 1024) + fdt_size;
130 	if (efi_allocate_pages(1, EFI_BOOT_SERVICES_DATA, fdt_pages,
131 			       &new_fdt_addr) != EFI_SUCCESS) {
132 		/* If we can't put it there, put it somewhere */
133 		new_fdt_addr = (ulong)memalign(4096, fdt_size);
134 	}
135 	new_fdt = (void*)(ulong)new_fdt_addr;
136 	memcpy(new_fdt, fdt, fdt_totalsize(fdt));
137 	fdt_set_totalsize(new_fdt, fdt_size);
138 
139 	return new_fdt;
140 }
141 
142 /*
143  * Load an EFI payload into a newly allocated piece of memory, register all
144  * EFI objects it would want to access and jump to it.
145  */
146 static unsigned long do_bootefi_exec(void *efi, void *fdt)
147 {
148 	ulong (*entry)(void *image_handle, struct efi_system_table *st);
149 	ulong fdt_pages, fdt_size, fdt_start, fdt_end;
150 	bootm_headers_t img = { 0 };
151 
152 	/*
153 	 * gd lives in a fixed register which may get clobbered while we execute
154 	 * the payload. So save it here and restore it on every callback entry
155 	 */
156 	efi_save_gd();
157 
158 	if (fdt && !fdt_check_header(fdt)) {
159 		/* Prepare fdt for payload */
160 		fdt = copy_fdt(fdt);
161 
162 		if (image_setup_libfdt(&img, fdt, 0, NULL)) {
163 			printf("ERROR: Failed to process device tree\n");
164 			return -EINVAL;
165 		}
166 
167 		/* Link to it in the efi tables */
168 		systab.tables[0].guid = EFI_FDT_GUID;
169 		systab.tables[0].table = fdt;
170 		systab.nr_tables = 1;
171 
172 		/* And reserve the space in the memory map */
173 		fdt_start = ((ulong)fdt) & ~EFI_PAGE_MASK;
174 		fdt_end = ((ulong)fdt) + fdt_totalsize(fdt);
175 		fdt_size = (fdt_end - fdt_start) + EFI_PAGE_MASK;
176 		fdt_pages = fdt_size >> EFI_PAGE_SHIFT;
177 		/* Give a bootloader the chance to modify the device tree */
178 		fdt_pages += 2;
179 		efi_add_memory_map(fdt_start, fdt_pages,
180 				   EFI_BOOT_SERVICES_DATA, true);
181 	} else {
182 		printf("WARNING: Invalid device tree, expect boot to fail\n");
183 		systab.nr_tables = 0;
184 	}
185 
186 	/* Load the EFI payload */
187 	entry = efi_load_pe(efi, &loaded_image_info);
188 	if (!entry)
189 		return -ENOENT;
190 
191 	/* Initialize and populate EFI object list */
192 	INIT_LIST_HEAD(&efi_obj_list);
193 	list_add_tail(&loaded_image_info_obj.link, &efi_obj_list);
194 	list_add_tail(&bootefi_device_obj.link, &efi_obj_list);
195 #ifdef CONFIG_PARTITIONS
196 	efi_disk_register();
197 #endif
198 #ifdef CONFIG_LCD
199 	efi_gop_register();
200 #endif
201 #ifdef CONFIG_NET
202 	void *nethandle = loaded_image_info.device_handle;
203 	efi_net_register(&nethandle);
204 
205 	if (!memcmp(bootefi_device_path[0].str, "N\0e\0t", 6))
206 		loaded_image_info.device_handle = nethandle;
207 #endif
208 
209 	/* Call our payload! */
210 	debug("%s:%d Jumping to 0x%lx\n", __func__, __LINE__, (long)entry);
211 
212 	if (setjmp(&loaded_image_info.exit_jmp)) {
213 		efi_status_t status = loaded_image_info.exit_status;
214 		return status == EFI_SUCCESS ? 0 : -EINVAL;
215 	}
216 
217 	return entry(&loaded_image_info, &systab);
218 }
219 
220 
221 /* Interpreter command to boot an arbitrary EFI image from memory */
222 static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
223 {
224 	char *saddr, *sfdt;
225 	unsigned long addr, fdt_addr = 0;
226 	int r = 0;
227 
228 	if (argc < 2)
229 		return CMD_RET_USAGE;
230 	saddr = argv[1];
231 
232 	addr = simple_strtoul(saddr, NULL, 16);
233 
234 	if (argc > 2) {
235 		sfdt = argv[2];
236 		fdt_addr = simple_strtoul(sfdt, NULL, 16);
237 	}
238 
239 	printf("## Starting EFI application at 0x%08lx ...\n", addr);
240 	r = do_bootefi_exec((void *)addr, (void*)fdt_addr);
241 	printf("## Application terminated, r = %d\n", r);
242 
243 	if (r != 0)
244 		r = 1;
245 
246 	return r;
247 }
248 
249 #ifdef CONFIG_SYS_LONGHELP
250 static char bootefi_help_text[] =
251 	"<image address> [fdt address]\n"
252 	"  - boot EFI payload stored at address <image address>.\n"
253 	"    If specified, the device tree located at <fdt address> gets\n"
254 	"    exposed as EFI configuration table.\n";
255 #endif
256 
257 U_BOOT_CMD(
258 	bootefi, 3, 0, do_bootefi,
259 	"Boots an EFI payload from memory",
260 	bootefi_help_text
261 );
262 
263 void efi_set_bootdev(const char *dev, const char *devnr, const char *path)
264 {
265 	__maybe_unused struct blk_desc *desc;
266 	char devname[32] = { 0 }; /* dp->str is u16[32] long */
267 	char *colon;
268 
269 #if defined(CONFIG_BLK) || defined(CONFIG_ISO_PARTITION)
270 	desc = blk_get_dev(dev, simple_strtol(devnr, NULL, 10));
271 #endif
272 
273 #ifdef CONFIG_BLK
274 	if (desc) {
275 		snprintf(devname, sizeof(devname), "%s", desc->bdev->name);
276 	} else
277 #endif
278 
279 	{
280 		/* Assemble the condensed device name we use in efi_disk.c */
281 		snprintf(devname, sizeof(devname), "%s%s", dev, devnr);
282 	}
283 
284 	colon = strchr(devname, ':');
285 
286 #ifdef CONFIG_ISO_PARTITION
287 	/* For ISOs we create partition block devices */
288 	if (desc && (desc->type != DEV_TYPE_UNKNOWN) &&
289 	    (desc->part_type == PART_TYPE_ISO)) {
290 		if (!colon)
291 			snprintf(devname, sizeof(devname), "%s:1", devname);
292 
293 		colon = NULL;
294 	}
295 #endif
296 
297 	if (colon)
298 		*colon = '\0';
299 
300 	/* Patch bootefi_device_path to the target device */
301 	memset(bootefi_device_path[0].str, 0, sizeof(bootefi_device_path[0].str));
302 	ascii2unicode(bootefi_device_path[0].str, devname);
303 
304 	/* Patch bootefi_image_path to the target file path */
305 	memset(bootefi_image_path[0].str, 0, sizeof(bootefi_image_path[0].str));
306 	if (strcmp(dev, "Net")) {
307 		/* Add leading / to fs paths, because they're absolute */
308 		snprintf(devname, sizeof(devname), "/%s", path);
309 	} else {
310 		snprintf(devname, sizeof(devname), "%s", path);
311 	}
312 	ascii2unicode(bootefi_image_path[0].str, devname);
313 }
314