]>
Commit | Line | Data |
---|---|---|
f739fcd8 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
b9939336 AG |
2 | /* |
3 | * EFI application loader | |
4 | * | |
5 | * Copyright (c) 2016 Alexander Graf | |
b9939336 AG |
6 | */ |
7 | ||
d78e40d6 | 8 | #include <charset.h> |
b9939336 AG |
9 | #include <common.h> |
10 | #include <command.h> | |
9d922450 | 11 | #include <dm.h> |
b9939336 | 12 | #include <efi_loader.h> |
d78e40d6 | 13 | #include <efi_selftest.h> |
b9939336 | 14 | #include <errno.h> |
b08c8c48 MY |
15 | #include <linux/libfdt.h> |
16 | #include <linux/libfdt_env.h> | |
354264b3 | 17 | #include <mapmem.h> |
ad0c1a3d | 18 | #include <memalign.h> |
0d9d501f | 19 | #include <asm/global_data.h> |
e275458c | 20 | #include <asm-generic/sections.h> |
c3b11dea | 21 | #include <asm-generic/unaligned.h> |
e275458c | 22 | #include <linux/linkage.h> |
0d9d501f | 23 | |
dc500c36 MK |
24 | #ifdef CONFIG_ARMV7_NONSEC |
25 | #include <asm/armv7.h> | |
26 | #include <asm/secure.h> | |
27 | #endif | |
28 | ||
0d9d501f | 29 | DECLARE_GLOBAL_DATA_PTR; |
b9939336 | 30 | |
fc225e60 HS |
31 | #define OBJ_LIST_NOT_INITIALIZED 1 |
32 | ||
33 | static efi_status_t efi_obj_list_initialized = OBJ_LIST_NOT_INITIALIZED; | |
7cbc1241 | 34 | |
95c5553e RC |
35 | static struct efi_device_path *bootefi_image_path; |
36 | static struct efi_device_path *bootefi_device_path; | |
b9939336 | 37 | |
7cbc1241 | 38 | /* Initialize and populate EFI object list */ |
fc225e60 | 39 | efi_status_t efi_init_obj_list(void) |
7cbc1241 | 40 | { |
fc225e60 HS |
41 | efi_status_t ret = EFI_SUCCESS; |
42 | ||
1e1e1c27 HS |
43 | /* |
44 | * On the ARM architecture gd is mapped to a fixed register (r9 or x18). | |
45 | * As this register may be overwritten by an EFI payload we save it here | |
46 | * and restore it on every callback entered. | |
47 | */ | |
48 | efi_save_gd(); | |
49 | ||
098a6cdd | 50 | /* Initialize once only */ |
fc225e60 HS |
51 | if (efi_obj_list_initialized != OBJ_LIST_NOT_INITIALIZED) |
52 | return efi_obj_list_initialized; | |
7cbc1241 | 53 | |
640adadf HS |
54 | /* Initialize system table */ |
55 | ret = efi_initialize_system_table(); | |
56 | if (ret != EFI_SUCCESS) | |
57 | goto out; | |
58 | ||
4e6b5d65 HS |
59 | /* Initialize root node */ |
60 | ret = efi_root_node_register(); | |
61 | if (ret != EFI_SUCCESS) | |
62 | goto out; | |
63 | ||
05ef48a2 | 64 | /* Initialize EFI driver uclass */ |
fc225e60 HS |
65 | ret = efi_driver_init(); |
66 | if (ret != EFI_SUCCESS) | |
67 | goto out; | |
05ef48a2 | 68 | |
fc225e60 HS |
69 | ret = efi_console_register(); |
70 | if (ret != EFI_SUCCESS) | |
71 | goto out; | |
7cbc1241 | 72 | #ifdef CONFIG_PARTITIONS |
fc225e60 HS |
73 | ret = efi_disk_register(); |
74 | if (ret != EFI_SUCCESS) | |
75 | goto out; | |
7cbc1241 HS |
76 | #endif |
77 | #if defined(CONFIG_LCD) || defined(CONFIG_DM_VIDEO) | |
fc225e60 HS |
78 | ret = efi_gop_register(); |
79 | if (ret != EFI_SUCCESS) | |
80 | goto out; | |
7cbc1241 | 81 | #endif |
092f2f35 | 82 | #ifdef CONFIG_NET |
fc225e60 HS |
83 | ret = efi_net_register(); |
84 | if (ret != EFI_SUCCESS) | |
85 | goto out; | |
7cbc1241 | 86 | #endif |
86df34d4 BM |
87 | #ifdef CONFIG_GENERATE_ACPI_TABLE |
88 | ret = efi_acpi_register(); | |
89 | if (ret != EFI_SUCCESS) | |
90 | goto out; | |
91 | #endif | |
7cbc1241 | 92 | #ifdef CONFIG_GENERATE_SMBIOS_TABLE |
fc225e60 HS |
93 | ret = efi_smbios_register(); |
94 | if (ret != EFI_SUCCESS) | |
95 | goto out; | |
7cbc1241 | 96 | #endif |
fc225e60 HS |
97 | ret = efi_watchdog_register(); |
98 | if (ret != EFI_SUCCESS) | |
99 | goto out; | |
7cbc1241 HS |
100 | |
101 | /* Initialize EFI runtime services */ | |
fc225e60 HS |
102 | ret = efi_reset_system_init(); |
103 | if (ret != EFI_SUCCESS) | |
104 | goto out; | |
fc225e60 HS |
105 | |
106 | out: | |
107 | efi_obj_list_initialized = ret; | |
108 | return ret; | |
7cbc1241 HS |
109 | } |
110 | ||
c3b11dea HS |
111 | /* |
112 | * Allow unaligned memory access. | |
113 | * | |
114 | * This routine is overridden by architectures providing this feature. | |
115 | */ | |
116 | void __weak allow_unaligned(void) | |
117 | { | |
118 | } | |
119 | ||
d78e40d6 HS |
120 | /* |
121 | * Set the load options of an image from an environment variable. | |
122 | * | |
123 | * @loaded_image_info: the image | |
124 | * @env_var: name of the environment variable | |
125 | */ | |
126 | static void set_load_options(struct efi_loaded_image *loaded_image_info, | |
127 | const char *env_var) | |
128 | { | |
129 | size_t size; | |
130 | const char *env = env_get(env_var); | |
7086a71a | 131 | u16 *pos; |
d78e40d6 HS |
132 | |
133 | loaded_image_info->load_options = NULL; | |
134 | loaded_image_info->load_options_size = 0; | |
135 | if (!env) | |
136 | return; | |
7086a71a | 137 | size = utf8_utf16_strlen(env) + 1; |
d78e40d6 HS |
138 | loaded_image_info->load_options = calloc(size, sizeof(u16)); |
139 | if (!loaded_image_info->load_options) { | |
140 | printf("ERROR: Out of memory\n"); | |
141 | return; | |
142 | } | |
7086a71a HS |
143 | pos = loaded_image_info->load_options; |
144 | utf8_utf16_strcpy(&pos, env); | |
d78e40d6 HS |
145 | loaded_image_info->load_options_size = size * 2; |
146 | } | |
147 | ||
9dff4900 SG |
148 | /** |
149 | * copy_fdt() - Copy the device tree to a new location available to EFI | |
150 | * | |
151 | * The FDT is relocated into a suitable location within the EFI memory map. | |
152 | * An additional 12KB is added to the space in case the device tree needs to be | |
153 | * expanded later with fdt_open_into(). | |
154 | * | |
4574d1b3 HS |
155 | * @fdt_addr: On entry, address of start of FDT. On exit, address of relocated |
156 | * FDT start | |
157 | * Return: status code | |
9dff4900 | 158 | */ |
4574d1b3 | 159 | static efi_status_t copy_fdt(ulong *fdt_addrp) |
0d9d501f | 160 | { |
ad0c1a3d | 161 | unsigned long fdt_ram_start = -1L, fdt_pages; |
9dff4900 SG |
162 | efi_status_t ret = 0; |
163 | void *fdt, *new_fdt; | |
ad0c1a3d | 164 | u64 new_fdt_addr; |
9dff4900 | 165 | uint fdt_size; |
ad0c1a3d | 166 | int i; |
0d9d501f | 167 | |
9dff4900 SG |
168 | for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { |
169 | u64 ram_start = gd->bd->bi_dram[i].start; | |
170 | u64 ram_size = gd->bd->bi_dram[i].size; | |
0d9d501f | 171 | |
ad0c1a3d AG |
172 | if (!ram_size) |
173 | continue; | |
174 | ||
175 | if (ram_start < fdt_ram_start) | |
176 | fdt_ram_start = ram_start; | |
177 | } | |
178 | ||
bc9a638a SG |
179 | /* |
180 | * Give us at least 4KB of breathing room in case the device tree needs | |
181 | * to be expanded later. Round up to the nearest EFI page boundary. | |
182 | */ | |
9dff4900 SG |
183 | fdt = map_sysmem(*fdt_addrp, 0); |
184 | fdt_size = fdt_totalsize(fdt); | |
185 | fdt_size += 4096 * 3; | |
bc9a638a | 186 | fdt_size = ALIGN(fdt_size + EFI_PAGE_SIZE - 1, EFI_PAGE_SIZE); |
ad0c1a3d AG |
187 | fdt_pages = fdt_size >> EFI_PAGE_SHIFT; |
188 | ||
baf70c02 SG |
189 | /* Safe fdt location is at 127MB */ |
190 | new_fdt_addr = fdt_ram_start + (127 * 1024 * 1024) + fdt_size; | |
9dff4900 SG |
191 | ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, |
192 | EFI_RUNTIME_SERVICES_DATA, fdt_pages, | |
193 | &new_fdt_addr); | |
194 | if (ret != EFI_SUCCESS) { | |
ad0c1a3d | 195 | /* If we can't put it there, put it somewhere */ |
a44bffcc | 196 | new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size); |
9dff4900 SG |
197 | ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, |
198 | EFI_RUNTIME_SERVICES_DATA, fdt_pages, | |
199 | &new_fdt_addr); | |
200 | if (ret != EFI_SUCCESS) { | |
85a6e9b3 | 201 | printf("ERROR: Failed to reserve space for FDT\n"); |
9dff4900 | 202 | goto done; |
85a6e9b3 | 203 | } |
ad0c1a3d | 204 | } |
85a6e9b3 | 205 | |
9dff4900 | 206 | new_fdt = map_sysmem(new_fdt_addr, fdt_size); |
0d9d501f AG |
207 | memcpy(new_fdt, fdt, fdt_totalsize(fdt)); |
208 | fdt_set_totalsize(new_fdt, fdt_size); | |
209 | ||
9dff4900 | 210 | *fdt_addrp = new_fdt_addr; |
9dff4900 SG |
211 | done: |
212 | return ret; | |
0d9d501f AG |
213 | } |
214 | ||
3eb0841b | 215 | static efi_status_t efi_do_enter( |
2074f700 | 216 | efi_handle_t image_handle, struct efi_system_table *st, |
c6fa5df6 AG |
217 | EFIAPI efi_status_t (*entry)( |
218 | efi_handle_t image_handle, | |
219 | struct efi_system_table *st)) | |
b06d8ac3 HS |
220 | { |
221 | efi_status_t ret = EFI_LOAD_ERROR; | |
222 | ||
223 | if (entry) | |
224 | ret = entry(image_handle, st); | |
225 | st->boottime->exit(image_handle, ret, 0, NULL); | |
226 | return ret; | |
227 | } | |
228 | ||
ec6617c3 | 229 | #ifdef CONFIG_ARM64 |
c6fa5df6 | 230 | static efi_status_t efi_run_in_el2(EFIAPI efi_status_t (*entry)( |
2074f700 HS |
231 | efi_handle_t image_handle, struct efi_system_table *st), |
232 | efi_handle_t image_handle, struct efi_system_table *st) | |
ec6617c3 AW |
233 | { |
234 | /* Enable caches again */ | |
235 | dcache_enable(); | |
236 | ||
b06d8ac3 | 237 | return efi_do_enter(image_handle, st, entry); |
ec6617c3 AW |
238 | } |
239 | #endif | |
240 | ||
dc500c36 | 241 | #ifdef CONFIG_ARMV7_NONSEC |
f17f2001 MK |
242 | static bool is_nonsec; |
243 | ||
dc500c36 MK |
244 | static efi_status_t efi_run_in_hyp(EFIAPI efi_status_t (*entry)( |
245 | efi_handle_t image_handle, struct efi_system_table *st), | |
246 | efi_handle_t image_handle, struct efi_system_table *st) | |
247 | { | |
248 | /* Enable caches again */ | |
249 | dcache_enable(); | |
250 | ||
f17f2001 MK |
251 | is_nonsec = true; |
252 | ||
dc500c36 MK |
253 | return efi_do_enter(image_handle, st, entry); |
254 | } | |
255 | #endif | |
256 | ||
416e07e2 SG |
257 | /* |
258 | * efi_carve_out_dt_rsv() - Carve out DT reserved memory ranges | |
259 | * | |
260 | * The mem_rsv entries of the FDT are added to the memory map. Any failures are | |
261 | * ignored because this is not critical and we would rather continue to try to | |
262 | * boot. | |
263 | * | |
264 | * @fdt: Pointer to device tree | |
265 | */ | |
266 | static void efi_carve_out_dt_rsv(void *fdt) | |
806d2fa8 AG |
267 | { |
268 | int nr_rsv, i; | |
269 | uint64_t addr, size, pages; | |
270 | ||
271 | nr_rsv = fdt_num_mem_rsv(fdt); | |
272 | ||
273 | /* Look for an existing entry and add it to the efi mem map. */ | |
274 | for (i = 0; i < nr_rsv; i++) { | |
275 | if (fdt_get_mem_rsv(fdt, i, &addr, &size) != 0) | |
276 | continue; | |
277 | ||
23fd84b3 HS |
278 | /* |
279 | * Do not carve out the device tree. It is already marked as | |
280 | * EFI_RUNTIME_SERVICES_DATA | |
281 | */ | |
282 | if (addr == (uintptr_t)fdt) | |
283 | continue; | |
284 | ||
285 | pages = ALIGN(size + (addr & EFI_PAGE_MASK), EFI_PAGE_SIZE) >> | |
286 | EFI_PAGE_SHIFT; | |
287 | addr &= ~EFI_PAGE_MASK; | |
416e07e2 SG |
288 | if (!efi_add_memory_map(addr, pages, EFI_RESERVED_MEMORY_TYPE, |
289 | false)) | |
290 | printf("FDT memrsv map %d: Failed to add to map\n", i); | |
806d2fa8 | 291 | } |
806d2fa8 AG |
292 | } |
293 | ||
9dff4900 | 294 | static efi_status_t efi_install_fdt(ulong fdt_addr) |
bc4f9133 HS |
295 | { |
296 | bootm_headers_t img = { 0 }; | |
bc4f9133 | 297 | efi_status_t ret; |
9dff4900 | 298 | void *fdt; |
bc4f9133 | 299 | |
9dff4900 | 300 | fdt = map_sysmem(fdt_addr, 0); |
bc4f9133 HS |
301 | if (fdt_check_header(fdt)) { |
302 | printf("ERROR: invalid device tree\n"); | |
303 | return EFI_INVALID_PARAMETER; | |
304 | } | |
305 | ||
306 | /* Prepare fdt for payload */ | |
4574d1b3 | 307 | ret = copy_fdt(&fdt_addr); |
9dff4900 SG |
308 | if (ret) |
309 | return ret; | |
bc4f9133 | 310 | |
9dff4900 SG |
311 | unmap_sysmem(fdt); |
312 | fdt = map_sysmem(fdt_addr, 0); | |
bc4f9133 HS |
313 | if (image_setup_libfdt(&img, fdt, 0, NULL)) { |
314 | printf("ERROR: failed to process device tree\n"); | |
315 | return EFI_LOAD_ERROR; | |
316 | } | |
317 | ||
416e07e2 | 318 | efi_carve_out_dt_rsv(fdt); |
806d2fa8 | 319 | |
bc4f9133 HS |
320 | /* Link to it in the efi tables */ |
321 | ret = efi_install_configuration_table(&efi_guid_fdt, fdt); | |
322 | if (ret != EFI_SUCCESS) | |
323 | return EFI_OUT_OF_RESOURCES; | |
324 | ||
bc4f9133 HS |
325 | return ret; |
326 | } | |
327 | ||
f4f0f7cb SG |
328 | static efi_status_t bootefi_run_prepare(const char *load_options_path, |
329 | struct efi_device_path *device_path, | |
330 | struct efi_device_path *image_path, | |
331 | struct efi_loaded_image_obj **image_objp, | |
332 | struct efi_loaded_image **loaded_image_infop) | |
333 | { | |
334 | efi_status_t ret; | |
335 | ||
336 | ret = efi_setup_loaded_image(device_path, image_path, image_objp, | |
337 | loaded_image_infop); | |
338 | if (ret != EFI_SUCCESS) | |
339 | return ret; | |
340 | ||
341 | /* Transfer environment variable as load options */ | |
342 | set_load_options(*loaded_image_infop, load_options_path); | |
343 | ||
344 | return 0; | |
345 | } | |
346 | ||
c982874e HS |
347 | /** |
348 | * do_bootefi_exec() - execute EFI binary | |
349 | * | |
350 | * @efi: address of the binary | |
351 | * @device_path: path of the device from which the binary was loaded | |
352 | * @image_path: device path of the binary | |
353 | * Return: status code | |
354 | * | |
355 | * Load the EFI binary into a newly assigned memory unwinding the relocation | |
356 | * information, install the loaded image protocol, and call the binary. | |
b9939336 | 357 | */ |
bc4f9133 | 358 | static efi_status_t do_bootefi_exec(void *efi, |
3eb0841b HS |
359 | struct efi_device_path *device_path, |
360 | struct efi_device_path *image_path) | |
b9939336 | 361 | { |
8887acc6 | 362 | efi_handle_t mem_handle = NULL; |
bf19273e | 363 | struct efi_device_path *memdp = NULL; |
45204b10 | 364 | efi_status_t ret; |
faea1041 | 365 | struct efi_loaded_image_obj *image_obj = NULL; |
c982874e | 366 | struct efi_loaded_image *loaded_image_info = NULL; |
95c5553e | 367 | |
c6fa5df6 AG |
368 | EFIAPI efi_status_t (*entry)(efi_handle_t image_handle, |
369 | struct efi_system_table *st); | |
b9939336 | 370 | |
bf19273e RC |
371 | /* |
372 | * Special case for efi payload not loaded from disk, such as | |
373 | * 'bootefi hello' or for example payload loaded directly into | |
e1fec152 | 374 | * memory via JTAG, etc: |
bf19273e RC |
375 | */ |
376 | if (!device_path && !image_path) { | |
377 | printf("WARNING: using memory device/image path, this may confuse some payloads!\n"); | |
378 | /* actual addresses filled in after efi_load_pe() */ | |
379 | memdp = efi_dp_from_mem(0, 0, 0); | |
380 | device_path = image_path = memdp; | |
8887acc6 HS |
381 | /* |
382 | * Grub expects that the device path of the loaded image is | |
383 | * installed on a handle. | |
384 | */ | |
385 | ret = efi_create_handle(&mem_handle); | |
386 | if (ret != EFI_SUCCESS) | |
387 | goto exit; | |
388 | ret = efi_add_protocol(mem_handle, &efi_guid_device_path, | |
58bc69d2 AG |
389 | device_path); |
390 | if (ret != EFI_SUCCESS) | |
391 | goto exit; | |
bf19273e RC |
392 | } else { |
393 | assert(device_path && image_path); | |
394 | } | |
395 | ||
f4f0f7cb SG |
396 | ret = bootefi_run_prepare("bootargs", device_path, image_path, |
397 | &image_obj, &loaded_image_info); | |
398 | if (ret) | |
399 | return ret; | |
95c5553e | 400 | |
b9939336 | 401 | /* Load the EFI payload */ |
faea1041 | 402 | entry = efi_load_pe(image_obj, efi, loaded_image_info); |
95c5553e | 403 | if (!entry) { |
45204b10 | 404 | ret = EFI_LOAD_ERROR; |
95c5553e RC |
405 | goto exit; |
406 | } | |
80a4800e | 407 | |
bf19273e RC |
408 | if (memdp) { |
409 | struct efi_device_path_memory *mdp = (void *)memdp; | |
c982874e HS |
410 | mdp->memory_type = loaded_image_info->image_code_type; |
411 | mdp->start_address = (uintptr_t)loaded_image_info->image_base; | |
bf19273e | 412 | mdp->end_address = mdp->start_address + |
c982874e | 413 | loaded_image_info->image_size; |
bf19273e RC |
414 | } |
415 | ||
ad644e7c RC |
416 | /* we don't support much: */ |
417 | env_set("efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported", | |
418 | "{ro,boot}(blob)0000000000000000"); | |
419 | ||
b9939336 | 420 | /* Call our payload! */ |
edcef3ba | 421 | debug("%s:%d Jumping to 0x%lx\n", __func__, __LINE__, (long)entry); |
a86aeaf2 | 422 | |
faea1041 HS |
423 | if (setjmp(&image_obj->exit_jmp)) { |
424 | ret = image_obj->exit_status; | |
95c5553e | 425 | goto exit; |
a86aeaf2 AG |
426 | } |
427 | ||
69bd459d AG |
428 | #ifdef CONFIG_ARM64 |
429 | /* On AArch64 we need to make sure we call our payload in < EL3 */ | |
430 | if (current_el() == 3) { | |
431 | smp_kick_all_cpus(); | |
432 | dcache_disable(); /* flush cache before switch to EL2 */ | |
ec6617c3 AW |
433 | |
434 | /* Move into EL2 and keep running there */ | |
ea54ad59 | 435 | armv8_switch_to_el2((ulong)entry, |
d39646a3 | 436 | (ulong)&image_obj->header, |
7c5e1feb | 437 | (ulong)&systab, 0, (ulong)efi_run_in_el2, |
ec6617c3 AW |
438 | ES_TO_AARCH64); |
439 | ||
440 | /* Should never reach here, efi exits with longjmp */ | |
441 | while (1) { } | |
69bd459d AG |
442 | } |
443 | #endif | |
444 | ||
dc500c36 | 445 | #ifdef CONFIG_ARMV7_NONSEC |
f17f2001 | 446 | if (armv7_boot_nonsec() && !is_nonsec) { |
dc500c36 MK |
447 | dcache_disable(); /* flush cache before switch to HYP */ |
448 | ||
449 | armv7_init_nonsec(); | |
450 | secure_ram_addr(_do_nonsec_entry)( | |
451 | efi_run_in_hyp, | |
452 | (uintptr_t)entry, | |
d39646a3 | 453 | (uintptr_t)&image_obj->header, |
dc500c36 MK |
454 | (uintptr_t)&systab); |
455 | ||
456 | /* Should never reach here, efi exits with longjmp */ | |
457 | while (1) { } | |
458 | } | |
459 | #endif | |
460 | ||
d39646a3 | 461 | ret = efi_do_enter(&image_obj->header, &systab, entry); |
95c5553e RC |
462 | |
463 | exit: | |
464 | /* image has returned, loaded-image obj goes *poof*: */ | |
faea1041 | 465 | if (image_obj) |
d39646a3 | 466 | efi_delete_handle(&image_obj->header); |
8887acc6 HS |
467 | if (mem_handle) |
468 | efi_delete_handle(mem_handle); | |
95c5553e RC |
469 | |
470 | return ret; | |
b9939336 AG |
471 | } |
472 | ||
d9717eae SG |
473 | #ifdef CONFIG_CMD_BOOTEFI_SELFTEST |
474 | /** | |
475 | * bootefi_test_prepare() - prepare to run an EFI test | |
476 | * | |
477 | * This sets things up so we can call EFI functions. This involves preparing | |
478 | * the 'gd' pointer and setting up the load ed image data structures. | |
479 | * | |
480 | * @image_objp: loaded_image_infop: Pointer to a struct which will hold the | |
481 | * loaded image object. This struct will be inited by this function before | |
482 | * use. | |
483 | * @loaded_image_infop: Pointer to a struct which will hold the loaded image | |
484 | * info. This struct will be inited by this function before use. | |
485 | * @path: File path to the test being run (often just the test name with a | |
486 | * backslash before it | |
487 | * @test_func: Address of the test function that is being run | |
f4f0f7cb | 488 | * @load_options_path: U-Boot environment variable to use as load options |
d9717eae SG |
489 | * @return 0 if OK, -ve on error |
490 | */ | |
491 | static efi_status_t bootefi_test_prepare | |
492 | (struct efi_loaded_image_obj **image_objp, | |
f4f0f7cb SG |
493 | struct efi_loaded_image **loaded_image_infop, const char *path, |
494 | ulong test_func, const char *load_options_path) | |
d9717eae | 495 | { |
d9717eae SG |
496 | /* Construct a dummy device path */ |
497 | bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, | |
498 | (uintptr_t)test_func, | |
499 | (uintptr_t)test_func); | |
500 | if (!bootefi_device_path) | |
501 | return EFI_OUT_OF_RESOURCES; | |
502 | bootefi_image_path = efi_dp_from_file(NULL, 0, path); | |
503 | if (!bootefi_image_path) | |
504 | return EFI_OUT_OF_RESOURCES; | |
d9717eae | 505 | |
f4f0f7cb SG |
506 | return bootefi_run_prepare(load_options_path, bootefi_device_path, |
507 | bootefi_image_path, image_objp, | |
508 | loaded_image_infop); | |
d9717eae SG |
509 | } |
510 | ||
511 | /** | |
512 | * bootefi_test_finish() - finish up after running an EFI test | |
513 | * | |
514 | * @image_obj: Pointer to a struct which holds the loaded image object | |
515 | * @loaded_image_info: Pointer to a struct which holds the loaded image info | |
516 | */ | |
517 | static void bootefi_test_finish(struct efi_loaded_image_obj *image_obj, | |
518 | struct efi_loaded_image *loaded_image_info) | |
519 | { | |
520 | efi_restore_gd(); | |
521 | free(loaded_image_info->load_options); | |
522 | efi_delete_handle(&image_obj->header); | |
523 | } | |
524 | #endif /* CONFIG_CMD_BOOTEFI_SELFTEST */ | |
525 | ||
bc4f9133 | 526 | static int do_bootefi_bootmgr_exec(void) |
9975fe96 RC |
527 | { |
528 | struct efi_device_path *device_path, *file_path; | |
529 | void *addr; | |
530 | efi_status_t r; | |
531 | ||
9975fe96 RC |
532 | addr = efi_bootmgr_load(&device_path, &file_path); |
533 | if (!addr) | |
534 | return 1; | |
535 | ||
536 | printf("## Starting EFI application at %p ...\n", addr); | |
bc4f9133 | 537 | r = do_bootefi_exec(addr, device_path, file_path); |
9975fe96 RC |
538 | printf("## Application terminated, r = %lu\n", |
539 | r & ~EFI_ERROR_MASK); | |
540 | ||
541 | if (r != EFI_SUCCESS) | |
542 | return 1; | |
543 | ||
544 | return 0; | |
545 | } | |
546 | ||
b9939336 AG |
547 | /* Interpreter command to boot an arbitrary EFI image from memory */ |
548 | static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) | |
549 | { | |
bc4f9133 HS |
550 | unsigned long addr; |
551 | char *saddr; | |
3eb0841b | 552 | efi_status_t r; |
354264b3 | 553 | unsigned long fdt_addr; |
b9939336 | 554 | |
c3b11dea HS |
555 | /* Allow unaligned memory access */ |
556 | allow_unaligned(); | |
557 | ||
fc225e60 HS |
558 | /* Initialize EFI drivers */ |
559 | r = efi_init_obj_list(); | |
560 | if (r != EFI_SUCCESS) { | |
561 | printf("Error: Cannot set up EFI drivers, r = %lu\n", | |
562 | r & ~EFI_ERROR_MASK); | |
563 | return CMD_RET_FAILURE; | |
564 | } | |
565 | ||
b9939336 | 566 | if (argc < 2) |
3c1dcef6 | 567 | return CMD_RET_USAGE; |
bc4f9133 HS |
568 | |
569 | if (argc > 2) { | |
354264b3 | 570 | fdt_addr = simple_strtoul(argv[2], NULL, 16); |
bc4f9133 HS |
571 | if (!fdt_addr && *argv[2] != '0') |
572 | return CMD_RET_USAGE; | |
573 | /* Install device tree */ | |
9dff4900 | 574 | r = efi_install_fdt(fdt_addr); |
bc4f9133 HS |
575 | if (r != EFI_SUCCESS) { |
576 | printf("ERROR: failed to install device tree\n"); | |
577 | return CMD_RET_FAILURE; | |
578 | } | |
579 | } else { | |
580 | /* Remove device tree. EFI_NOT_FOUND can be ignored here */ | |
581 | efi_install_configuration_table(&efi_guid_fdt, NULL); | |
582 | printf("WARNING: booting without device tree\n"); | |
583 | } | |
c7ae3dfd SG |
584 | #ifdef CONFIG_CMD_BOOTEFI_HELLO |
585 | if (!strcmp(argv[1], "hello")) { | |
5e44489b | 586 | ulong size = __efi_helloworld_end - __efi_helloworld_begin; |
b9939336 | 587 | |
51c533fd HS |
588 | saddr = env_get("loadaddr"); |
589 | if (saddr) | |
590 | addr = simple_strtoul(saddr, NULL, 16); | |
591 | else | |
592 | addr = CONFIG_SYS_LOAD_ADDR; | |
354264b3 | 593 | memcpy(map_sysmem(addr, size), __efi_helloworld_begin, size); |
c7ae3dfd | 594 | } else |
623b3a57 HS |
595 | #endif |
596 | #ifdef CONFIG_CMD_BOOTEFI_SELFTEST | |
597 | if (!strcmp(argv[1], "selftest")) { | |
faea1041 | 598 | struct efi_loaded_image_obj *image_obj; |
c982874e | 599 | struct efi_loaded_image *loaded_image_info; |
7aca68ca | 600 | |
d9717eae | 601 | if (bootefi_test_prepare(&image_obj, &loaded_image_info, |
f4f0f7cb SG |
602 | "\\selftest", (uintptr_t)&efi_selftest, |
603 | "efi_selftest")) | |
2ab7ef74 | 604 | return CMD_RET_FAILURE; |
f972dc14 | 605 | |
d78e40d6 | 606 | /* Execute the test */ |
d39646a3 | 607 | r = efi_selftest(&image_obj->header, &systab); |
d9717eae | 608 | bootefi_test_finish(image_obj, loaded_image_info); |
c2b53902 | 609 | return r != EFI_SUCCESS; |
623b3a57 | 610 | } else |
c7ae3dfd | 611 | #endif |
9975fe96 | 612 | if (!strcmp(argv[1], "bootmgr")) { |
bc4f9133 | 613 | return do_bootefi_bootmgr_exec(); |
9975fe96 | 614 | } else { |
c7ae3dfd | 615 | saddr = argv[1]; |
b9939336 | 616 | |
c7ae3dfd | 617 | addr = simple_strtoul(saddr, NULL, 16); |
49db1cb8 HS |
618 | /* Check that a numeric value was passed */ |
619 | if (!addr && *saddr != '0') | |
620 | return CMD_RET_USAGE; | |
c7ae3dfd | 621 | |
1c39809b AG |
622 | } |
623 | ||
5ee31baf | 624 | printf("## Starting EFI application at %08lx ...\n", addr); |
354264b3 | 625 | r = do_bootefi_exec(map_sysmem(addr, 0), bootefi_device_path, |
bc4f9133 | 626 | bootefi_image_path); |
1da1bac4 HS |
627 | printf("## Application terminated, r = %lu\n", |
628 | r & ~EFI_ERROR_MASK); | |
b9939336 | 629 | |
1da1bac4 HS |
630 | if (r != EFI_SUCCESS) |
631 | return 1; | |
632 | else | |
633 | return 0; | |
b9939336 AG |
634 | } |
635 | ||
636 | #ifdef CONFIG_SYS_LONGHELP | |
637 | static char bootefi_help_text[] = | |
1c39809b AG |
638 | "<image address> [fdt address]\n" |
639 | " - boot EFI payload stored at address <image address>.\n" | |
640 | " If specified, the device tree located at <fdt address> gets\n" | |
c7ae3dfd SG |
641 | " exposed as EFI configuration table.\n" |
642 | #ifdef CONFIG_CMD_BOOTEFI_HELLO | |
623b3a57 HS |
643 | "bootefi hello\n" |
644 | " - boot a sample Hello World application stored within U-Boot\n" | |
645 | #endif | |
646 | #ifdef CONFIG_CMD_BOOTEFI_SELFTEST | |
bc4f9133 | 647 | "bootefi selftest [fdt address]\n" |
623b3a57 | 648 | " - boot an EFI selftest application stored within U-Boot\n" |
d78e40d6 HS |
649 | " Use environment variable efi_selftest to select a single test.\n" |
650 | " Use 'setenv efi_selftest list' to enumerate all tests.\n" | |
c7ae3dfd | 651 | #endif |
f623e07f | 652 | "bootefi bootmgr [fdt addr]\n" |
9975fe96 RC |
653 | " - load and boot EFI payload based on BootOrder/BootXXXX variables.\n" |
654 | "\n" | |
655 | " If specified, the device tree located at <fdt address> gets\n" | |
656 | " exposed as EFI configuration table.\n"; | |
b9939336 AG |
657 | #endif |
658 | ||
659 | U_BOOT_CMD( | |
1c39809b | 660 | bootefi, 3, 0, do_bootefi, |
92dfd922 | 661 | "Boots an EFI payload from memory", |
b9939336 AG |
662 | bootefi_help_text |
663 | ); | |
0f4060eb | 664 | |
95c5553e RC |
665 | void efi_set_bootdev(const char *dev, const char *devnr, const char *path) |
666 | { | |
f1589ffb AT |
667 | struct efi_device_path *device, *image; |
668 | efi_status_t ret; | |
f9d334bd | 669 | |
79276eb2 HS |
670 | /* efi_set_bootdev is typically called repeatedly, recover memory */ |
671 | efi_free_pool(bootefi_device_path); | |
672 | efi_free_pool(bootefi_image_path); | |
9975fe96 | 673 | |
f1589ffb AT |
674 | ret = efi_dp_from_name(dev, devnr, path, &device, &image); |
675 | if (ret == EFI_SUCCESS) { | |
676 | bootefi_device_path = device; | |
677 | bootefi_image_path = image; | |
49271666 | 678 | } else { |
f1589ffb AT |
679 | bootefi_device_path = NULL; |
680 | bootefi_image_path = NULL; | |
49271666 | 681 | } |
0f4060eb | 682 | } |