]>
Commit | Line | Data |
---|---|---|
b9939336 AG |
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> | |
f9d334bd | 11 | #include <dm/device.h> |
b9939336 AG |
12 | #include <efi_loader.h> |
13 | #include <errno.h> | |
14 | #include <libfdt.h> | |
15 | #include <libfdt_env.h> | |
ad0c1a3d | 16 | #include <memalign.h> |
0d9d501f | 17 | #include <asm/global_data.h> |
e275458c SG |
18 | #include <asm-generic/sections.h> |
19 | #include <linux/linkage.h> | |
0d9d501f AG |
20 | |
21 | DECLARE_GLOBAL_DATA_PTR; | |
b9939336 AG |
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 | */ | |
0f4060eb | 31 | static struct efi_device_path_file_path bootefi_image_path[] = { |
b9939336 AG |
32 | { |
33 | .dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE, | |
34 | .dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH, | |
0f4060eb | 35 | .dp.length = sizeof(bootefi_image_path[0]), |
b9939336 AG |
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, | |
0f4060eb | 40 | .dp.length = sizeof(bootefi_image_path[0]), |
b9939336 AG |
41 | } |
42 | }; | |
43 | ||
c07ad7c0 AG |
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 | ||
e275458c | 57 | static efi_status_t EFIAPI bootefi_open_dp(void *handle, efi_guid_t *protocol, |
b9939336 AG |
58 | void **protocol_interface, void *agent_handle, |
59 | void *controller_handle, uint32_t attributes) | |
60 | { | |
c07ad7c0 | 61 | *protocol_interface = bootefi_device_path; |
b9939336 AG |
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 = { | |
c07ad7c0 | 67 | .device_handle = bootefi_device_path, |
0f4060eb | 68 | .file_path = bootefi_image_path, |
b9939336 AG |
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 | |
c07ad7c0 | 86 | * bootefi_device_path |
b9939336 AG |
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 = { | |
c07ad7c0 | 96 | .handle = bootefi_device_path, |
b9939336 AG |
97 | .protocols = { |
98 | { | |
99 | /* When asking for the device path interface, return | |
c07ad7c0 | 100 | * bootefi_device_path */ |
b9939336 AG |
101 | .guid = &efi_guid_device_path, |
102 | .open = &bootefi_open_dp, | |
103 | } | |
104 | }, | |
105 | }; | |
106 | ||
0d9d501f AG |
107 | static void *copy_fdt(void *fdt) |
108 | { | |
109 | u64 fdt_size = fdt_totalsize(fdt); | |
ad0c1a3d AG |
110 | unsigned long fdt_ram_start = -1L, fdt_pages; |
111 | u64 new_fdt_addr; | |
0d9d501f | 112 | void *new_fdt; |
ad0c1a3d | 113 | int i; |
0d9d501f | 114 | |
ad0c1a3d AG |
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; | |
0d9d501f | 118 | |
ad0c1a3d AG |
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; | |
0d9d501f AG |
138 | memcpy(new_fdt, fdt, fdt_totalsize(fdt)); |
139 | fdt_set_totalsize(new_fdt, fdt_size); | |
140 | ||
141 | return new_fdt; | |
142 | } | |
143 | ||
ec6617c3 AW |
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 | ||
b9939336 AG |
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 | */ | |
1c39809b | 160 | static unsigned long do_bootefi_exec(void *efi, void *fdt) |
b9939336 | 161 | { |
e275458c SG |
162 | ulong (*entry)(void *image_handle, struct efi_system_table *st) |
163 | asmlinkage; | |
b9939336 | 164 | ulong fdt_pages, fdt_size, fdt_start, fdt_end; |
dea2174d | 165 | bootm_headers_t img = { 0 }; |
b9939336 AG |
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 | ||
1c39809b | 173 | if (fdt && !fdt_check_header(fdt)) { |
dea2174d | 174 | /* Prepare fdt for payload */ |
0d9d501f AG |
175 | fdt = copy_fdt(fdt); |
176 | ||
177 | if (image_setup_libfdt(&img, fdt, 0, NULL)) { | |
dea2174d AG |
178 | printf("ERROR: Failed to process device tree\n"); |
179 | return -EINVAL; | |
180 | } | |
181 | ||
182 | /* Link to it in the efi tables */ | |
b9939336 | 183 | systab.tables[0].guid = EFI_FDT_GUID; |
0d9d501f | 184 | systab.tables[0].table = fdt; |
b9939336 AG |
185 | systab.nr_tables = 1; |
186 | ||
187 | /* And reserve the space in the memory map */ | |
0d9d501f AG |
188 | fdt_start = ((ulong)fdt) & ~EFI_PAGE_MASK; |
189 | fdt_end = ((ulong)fdt) + fdt_totalsize(fdt); | |
b9939336 AG |
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); | |
b9939336 | 196 | } else { |
1c39809b | 197 | printf("WARNING: Invalid device tree, expect boot to fail\n"); |
b9939336 AG |
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 | |
be8d3241 AG |
213 | #ifdef CONFIG_LCD |
214 | efi_gop_register(); | |
215 | #endif | |
0efe1bcf AG |
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; | |
3fb97e26 AG |
222 | else |
223 | loaded_image_info.device_handle = bootefi_device_path; | |
0efe1bcf | 224 | #endif |
e663b350 AG |
225 | #ifdef CONFIG_GENERATE_SMBIOS_TABLE |
226 | efi_smbios_register(); | |
227 | #endif | |
b9939336 | 228 | |
80a4800e AG |
229 | /* Initialize EFI runtime services */ |
230 | efi_reset_system_init(); | |
231 | efi_get_time_init(); | |
232 | ||
b9939336 | 233 | /* Call our payload! */ |
edcef3ba | 234 | debug("%s:%d Jumping to 0x%lx\n", __func__, __LINE__, (long)entry); |
a86aeaf2 AG |
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 | ||
69bd459d AG |
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 */ | |
ec6617c3 AW |
246 | |
247 | /* Move into EL2 and keep running there */ | |
248 | armv8_switch_to_el2((ulong)entry, (ulong)&loaded_image_info, | |
7c5e1feb | 249 | (ulong)&systab, 0, (ulong)efi_run_in_el2, |
ec6617c3 AW |
250 | ES_TO_AARCH64); |
251 | ||
252 | /* Should never reach here, efi exits with longjmp */ | |
253 | while (1) { } | |
69bd459d AG |
254 | } |
255 | #endif | |
256 | ||
b9939336 AG |
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 | { | |
1c39809b AG |
264 | char *saddr, *sfdt; |
265 | unsigned long addr, fdt_addr = 0; | |
b9939336 AG |
266 | int r = 0; |
267 | ||
268 | if (argc < 2) | |
3c1dcef6 | 269 | return CMD_RET_USAGE; |
c7ae3dfd SG |
270 | #ifdef CONFIG_CMD_BOOTEFI_HELLO |
271 | if (!strcmp(argv[1], "hello")) { | |
272 | ulong size = __efi_hello_world_end - __efi_hello_world_begin; | |
b9939336 | 273 | |
c7ae3dfd SG |
274 | addr = CONFIG_SYS_LOAD_ADDR; |
275 | memcpy((char *)addr, __efi_hello_world_begin, size); | |
276 | } else | |
277 | #endif | |
278 | { | |
279 | saddr = argv[1]; | |
b9939336 | 280 | |
c7ae3dfd SG |
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 | } | |
1c39809b AG |
287 | } |
288 | ||
5ee31baf | 289 | printf("## Starting EFI application at %08lx ...\n", addr); |
1c39809b | 290 | r = do_bootefi_exec((void *)addr, (void*)fdt_addr); |
b9939336 AG |
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[] = | |
1c39809b AG |
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" | |
c7ae3dfd SG |
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 | ; | |
b9939336 AG |
310 | #endif |
311 | ||
312 | U_BOOT_CMD( | |
1c39809b | 313 | bootefi, 3, 0, do_bootefi, |
92dfd922 | 314 | "Boots an EFI payload from memory", |
b9939336 AG |
315 | bootefi_help_text |
316 | ); | |
0f4060eb | 317 | |
c07ad7c0 | 318 | void efi_set_bootdev(const char *dev, const char *devnr, const char *path) |
0f4060eb | 319 | { |
8c3df0bf | 320 | __maybe_unused struct blk_desc *desc; |
ecbe1a07 | 321 | char devname[32] = { 0 }; /* dp->str is u16[32] long */ |
0f4060eb AG |
322 | char *colon; |
323 | ||
1acc0087 | 324 | #if defined(CONFIG_BLK) || CONFIG_IS_ENABLED(ISO_PARTITION) |
f9d334bd AG |
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 | ||
0f4060eb | 339 | colon = strchr(devname, ':'); |
8c3df0bf | 340 | |
1acc0087 | 341 | #if CONFIG_IS_ENABLED(ISO_PARTITION) |
8c3df0bf | 342 | /* For ISOs we create partition block devices */ |
8c3df0bf AG |
343 | if (desc && (desc->type != DEV_TYPE_UNKNOWN) && |
344 | (desc->part_type == PART_TYPE_ISO)) { | |
345 | if (!colon) | |
f9d334bd AG |
346 | snprintf(devname, sizeof(devname), "%s:1", devname); |
347 | ||
8c3df0bf AG |
348 | colon = NULL; |
349 | } | |
350 | #endif | |
351 | ||
0f4060eb AG |
352 | if (colon) |
353 | *colon = '\0'; | |
354 | ||
c07ad7c0 AG |
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 */ | |
0f4060eb | 360 | memset(bootefi_image_path[0].str, 0, sizeof(bootefi_image_path[0].str)); |
49271666 AG |
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 | } | |
0f4060eb AG |
367 | ascii2unicode(bootefi_image_path[0].str, devname); |
368 | } |