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