]>
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 | ||
8 | #include <common.h> | |
f6c6df7e | 9 | #include <charset.h> |
b9939336 | 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> |
e275458c SG |
19 | #include <asm-generic/sections.h> |
20 | #include <linux/linkage.h> | |
0d9d501f AG |
21 | |
22 | DECLARE_GLOBAL_DATA_PTR; | |
b9939336 | 23 | |
95c5553e RC |
24 | static struct efi_device_path *bootefi_image_path; |
25 | static struct efi_device_path *bootefi_device_path; | |
b9939336 | 26 | |
d78e40d6 HS |
27 | /* |
28 | * Set the load options of an image from an environment variable. | |
29 | * | |
defa7b8e AT |
30 | * @handle: the image handle |
31 | * @env_var: name of the environment variable | |
32 | * Return: status code | |
d78e40d6 | 33 | */ |
defa7b8e | 34 | static efi_status_t set_load_options(efi_handle_t handle, const char *env_var) |
d78e40d6 | 35 | { |
defa7b8e | 36 | struct efi_loaded_image *loaded_image_info; |
d78e40d6 HS |
37 | size_t size; |
38 | const char *env = env_get(env_var); | |
7086a71a | 39 | u16 *pos; |
defa7b8e AT |
40 | efi_status_t ret; |
41 | ||
42 | ret = EFI_CALL(systab.boottime->open_protocol( | |
43 | handle, | |
44 | &efi_guid_loaded_image, | |
45 | (void **)&loaded_image_info, | |
46 | efi_root, NULL, | |
47 | EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL)); | |
48 | if (ret != EFI_SUCCESS) | |
49 | return EFI_INVALID_PARAMETER; | |
d78e40d6 HS |
50 | |
51 | loaded_image_info->load_options = NULL; | |
52 | loaded_image_info->load_options_size = 0; | |
53 | if (!env) | |
defa7b8e AT |
54 | goto out; |
55 | ||
7086a71a | 56 | size = utf8_utf16_strlen(env) + 1; |
d78e40d6 HS |
57 | loaded_image_info->load_options = calloc(size, sizeof(u16)); |
58 | if (!loaded_image_info->load_options) { | |
59 | printf("ERROR: Out of memory\n"); | |
defa7b8e AT |
60 | EFI_CALL(systab.boottime->close_protocol(handle, |
61 | &efi_guid_loaded_image, | |
62 | efi_root, NULL)); | |
63 | return EFI_OUT_OF_RESOURCES; | |
d78e40d6 | 64 | } |
7086a71a HS |
65 | pos = loaded_image_info->load_options; |
66 | utf8_utf16_strcpy(&pos, env); | |
d78e40d6 | 67 | loaded_image_info->load_options_size = size * 2; |
defa7b8e AT |
68 | |
69 | out: | |
70 | return EFI_CALL(systab.boottime->close_protocol(handle, | |
71 | &efi_guid_loaded_image, | |
72 | efi_root, NULL)); | |
d78e40d6 HS |
73 | } |
74 | ||
6182495e HS |
75 | #if !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE) |
76 | ||
9dff4900 SG |
77 | /** |
78 | * copy_fdt() - Copy the device tree to a new location available to EFI | |
79 | * | |
16b615d9 | 80 | * The FDT is copied to a suitable location within the EFI memory map. |
c3772ca1 | 81 | * Additional 12 KiB are added to the space in case the device tree needs to be |
9dff4900 SG |
82 | * expanded later with fdt_open_into(). |
83 | * | |
16b615d9 HS |
84 | * @fdtp: On entry a pointer to the flattened device tree. |
85 | * On exit a pointer to the copy of the flattened device tree. | |
4574d1b3 HS |
86 | * FDT start |
87 | * Return: status code | |
9dff4900 | 88 | */ |
16b615d9 | 89 | static efi_status_t copy_fdt(void **fdtp) |
0d9d501f | 90 | { |
ad0c1a3d | 91 | unsigned long fdt_ram_start = -1L, fdt_pages; |
9dff4900 SG |
92 | efi_status_t ret = 0; |
93 | void *fdt, *new_fdt; | |
ad0c1a3d | 94 | u64 new_fdt_addr; |
9dff4900 | 95 | uint fdt_size; |
ad0c1a3d | 96 | int i; |
0d9d501f | 97 | |
9dff4900 SG |
98 | for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { |
99 | u64 ram_start = gd->bd->bi_dram[i].start; | |
100 | u64 ram_size = gd->bd->bi_dram[i].size; | |
0d9d501f | 101 | |
ad0c1a3d AG |
102 | if (!ram_size) |
103 | continue; | |
104 | ||
105 | if (ram_start < fdt_ram_start) | |
106 | fdt_ram_start = ram_start; | |
107 | } | |
108 | ||
bc9a638a | 109 | /* |
c3772ca1 HS |
110 | * Give us at least 12 KiB of breathing room in case the device tree |
111 | * needs to be expanded later. | |
bc9a638a | 112 | */ |
16b615d9 | 113 | fdt = *fdtp; |
c3772ca1 HS |
114 | fdt_pages = efi_size_in_pages(fdt_totalsize(fdt) + 0x3000); |
115 | fdt_size = fdt_pages << EFI_PAGE_SHIFT; | |
ad0c1a3d | 116 | |
16b615d9 HS |
117 | /* |
118 | * Safe fdt location is at 127 MiB. | |
119 | * On the sandbox convert from the sandbox address space. | |
120 | */ | |
121 | new_fdt_addr = (uintptr_t)map_sysmem(fdt_ram_start + 0x7f00000 + | |
122 | fdt_size, 0); | |
9dff4900 | 123 | ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, |
29361ec4 | 124 | EFI_BOOT_SERVICES_DATA, fdt_pages, |
9dff4900 SG |
125 | &new_fdt_addr); |
126 | if (ret != EFI_SUCCESS) { | |
ad0c1a3d | 127 | /* If we can't put it there, put it somewhere */ |
a44bffcc | 128 | new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size); |
9dff4900 | 129 | ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, |
29361ec4 | 130 | EFI_BOOT_SERVICES_DATA, fdt_pages, |
9dff4900 SG |
131 | &new_fdt_addr); |
132 | if (ret != EFI_SUCCESS) { | |
85a6e9b3 | 133 | printf("ERROR: Failed to reserve space for FDT\n"); |
9dff4900 | 134 | goto done; |
85a6e9b3 | 135 | } |
ad0c1a3d | 136 | } |
16b615d9 | 137 | new_fdt = (void *)(uintptr_t)new_fdt_addr; |
0d9d501f AG |
138 | memcpy(new_fdt, fdt, fdt_totalsize(fdt)); |
139 | fdt_set_totalsize(new_fdt, fdt_size); | |
140 | ||
16b615d9 | 141 | *fdtp = (void *)(uintptr_t)new_fdt_addr; |
9dff4900 SG |
142 | done: |
143 | return ret; | |
0d9d501f AG |
144 | } |
145 | ||
416e07e2 SG |
146 | /* |
147 | * efi_carve_out_dt_rsv() - Carve out DT reserved memory ranges | |
148 | * | |
149 | * The mem_rsv entries of the FDT are added to the memory map. Any failures are | |
150 | * ignored because this is not critical and we would rather continue to try to | |
151 | * boot. | |
152 | * | |
153 | * @fdt: Pointer to device tree | |
154 | */ | |
155 | static void efi_carve_out_dt_rsv(void *fdt) | |
806d2fa8 AG |
156 | { |
157 | int nr_rsv, i; | |
158 | uint64_t addr, size, pages; | |
159 | ||
160 | nr_rsv = fdt_num_mem_rsv(fdt); | |
161 | ||
162 | /* Look for an existing entry and add it to the efi mem map. */ | |
163 | for (i = 0; i < nr_rsv; i++) { | |
164 | if (fdt_get_mem_rsv(fdt, i, &addr, &size) != 0) | |
165 | continue; | |
166 | ||
16b615d9 HS |
167 | /* Convert from sandbox address space. */ |
168 | addr = (uintptr_t)map_sysmem(addr, 0); | |
169 | ||
c3772ca1 | 170 | pages = efi_size_in_pages(size + (addr & EFI_PAGE_MASK)); |
23fd84b3 | 171 | addr &= ~EFI_PAGE_MASK; |
416e07e2 SG |
172 | if (!efi_add_memory_map(addr, pages, EFI_RESERVED_MEMORY_TYPE, |
173 | false)) | |
174 | printf("FDT memrsv map %d: Failed to add to map\n", i); | |
806d2fa8 | 175 | } |
806d2fa8 AG |
176 | } |
177 | ||
6182495e HS |
178 | /** |
179 | * get_config_table() - get configuration table | |
180 | * | |
181 | * @guid: GUID of the configuration table | |
182 | * Return: pointer to configuration table or NULL | |
183 | */ | |
184 | static void *get_config_table(const efi_guid_t *guid) | |
185 | { | |
186 | size_t i; | |
187 | ||
188 | for (i = 0; i < systab.nr_tables; i++) { | |
189 | if (!guidcmp(guid, &systab.tables[i].guid)) | |
190 | return systab.tables[i].table; | |
191 | } | |
192 | return NULL; | |
193 | } | |
194 | ||
195 | #endif /* !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE) */ | |
196 | ||
e878e6a7 | 197 | /** |
3ffc52fd | 198 | * efi_install_fdt() - install fdt passed by a command argument |
e2d82f8b HS |
199 | * |
200 | * If fdt_opt is available, the device tree located at that memory address will | |
201 | * will be installed as configuration table, otherwise the device tree located | |
202 | * at the address indicated by environment variable fdtcontroladdr will be used. | |
203 | * | |
204 | * On architectures (x86) using ACPI tables device trees shall not be installed | |
205 | * as configuration table. | |
206 | * | |
e878e6a7 AT |
207 | * @fdt_opt: pointer to argument |
208 | * Return: status code | |
e878e6a7 | 209 | */ |
3ffc52fd | 210 | static efi_status_t efi_install_fdt(const char *fdt_opt) |
e878e6a7 | 211 | { |
6182495e HS |
212 | /* |
213 | * The EBBR spec requires that we have either an FDT or an ACPI table | |
214 | * but not both. | |
215 | */ | |
216 | #if CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE) | |
217 | if (fdt_opt) { | |
218 | printf("ERROR: can't have ACPI table and device tree.\n"); | |
219 | return EFI_LOAD_ERROR; | |
220 | } | |
221 | #else | |
e878e6a7 | 222 | unsigned long fdt_addr; |
3ffc52fd AT |
223 | void *fdt; |
224 | bootm_headers_t img = { 0 }; | |
e878e6a7 AT |
225 | efi_status_t ret; |
226 | ||
227 | if (fdt_opt) { | |
228 | fdt_addr = simple_strtoul(fdt_opt, NULL, 16); | |
6182495e | 229 | if (!fdt_addr) |
3ffc52fd | 230 | return EFI_INVALID_PARAMETER; |
6182495e HS |
231 | } else { |
232 | /* Look for device tree that is already installed */ | |
233 | if (get_config_table(&efi_guid_fdt)) | |
234 | return EFI_SUCCESS; | |
235 | /* Use our own device tree as default */ | |
236 | fdt_opt = env_get("fdtcontroladdr"); | |
237 | if (!fdt_opt) { | |
238 | printf("ERROR: need device tree\n"); | |
239 | return EFI_NOT_FOUND; | |
240 | } | |
241 | fdt_addr = simple_strtoul(fdt_opt, NULL, 16); | |
242 | if (!fdt_addr) { | |
243 | printf("ERROR: invalid $fdtcontroladdr\n"); | |
244 | return EFI_LOAD_ERROR; | |
3ffc52fd | 245 | } |
6182495e | 246 | } |
3ffc52fd | 247 | |
6182495e HS |
248 | /* Install device tree */ |
249 | fdt = map_sysmem(fdt_addr, 0); | |
250 | if (fdt_check_header(fdt)) { | |
251 | printf("ERROR: invalid device tree\n"); | |
252 | return EFI_LOAD_ERROR; | |
253 | } | |
3ffc52fd | 254 | |
6182495e HS |
255 | /* Create memory reservations as indicated by the device tree */ |
256 | efi_carve_out_dt_rsv(fdt); | |
3ffc52fd | 257 | |
6182495e HS |
258 | /* Prepare device tree for payload */ |
259 | ret = copy_fdt(&fdt); | |
260 | if (ret) { | |
261 | printf("ERROR: out of memory\n"); | |
262 | return EFI_OUT_OF_RESOURCES; | |
263 | } | |
3ffc52fd | 264 | |
6182495e HS |
265 | if (image_setup_libfdt(&img, fdt, 0, NULL)) { |
266 | printf("ERROR: failed to process device tree\n"); | |
267 | return EFI_LOAD_ERROR; | |
268 | } | |
269 | ||
270 | /* Install device tree as UEFI table */ | |
271 | ret = efi_install_configuration_table(&efi_guid_fdt, fdt); | |
272 | if (ret != EFI_SUCCESS) { | |
273 | printf("ERROR: failed to install device tree\n"); | |
274 | return ret; | |
e878e6a7 | 275 | } |
6182495e | 276 | #endif /* GENERATE_ACPI_TABLE */ |
e878e6a7 AT |
277 | |
278 | return EFI_SUCCESS; | |
279 | } | |
280 | ||
c982874e HS |
281 | /** |
282 | * do_bootefi_exec() - execute EFI binary | |
283 | * | |
6b95b38c | 284 | * @handle: handle of loaded image |
c982874e HS |
285 | * Return: status code |
286 | * | |
287 | * Load the EFI binary into a newly assigned memory unwinding the relocation | |
288 | * information, install the loaded image protocol, and call the binary. | |
b9939336 | 289 | */ |
6b95b38c | 290 | static efi_status_t do_bootefi_exec(efi_handle_t handle) |
b9939336 | 291 | { |
45204b10 | 292 | efi_status_t ret; |
556d8dc9 HS |
293 | efi_uintn_t exit_data_size = 0; |
294 | u16 *exit_data = NULL; | |
95c5553e | 295 | |
3fc2b163 | 296 | /* Transfer environment variable as load options */ |
6b95b38c | 297 | ret = set_load_options(handle, "bootargs"); |
8f7e2b29 | 298 | if (ret != EFI_SUCCESS) |
6b95b38c | 299 | return ret; |
bf19273e | 300 | |
b9939336 | 301 | /* Call our payload! */ |
556d8dc9 HS |
302 | ret = EFI_CALL(efi_start_image(handle, &exit_data_size, &exit_data)); |
303 | printf("## Application terminated, r = %lu\n", ret & ~EFI_ERROR_MASK); | |
304 | if (ret && exit_data) { | |
305 | printf("## %ls\n", exit_data); | |
306 | efi_free_pool(exit_data); | |
307 | } | |
95c5553e | 308 | |
3fc2b163 | 309 | efi_restore_gd(); |
5e2f0391 | 310 | |
6b95b38c AT |
311 | /* |
312 | * FIXME: Who is responsible for | |
313 | * free(loaded_image_info->load_options); | |
314 | * Once efi_exit() is implemented correctly, | |
315 | * handle itself doesn't exist here. | |
316 | */ | |
95c5553e RC |
317 | |
318 | return ret; | |
b9939336 AG |
319 | } |
320 | ||
d6b21894 | 321 | /** |
7e92db81 | 322 | * do_efibootmgr() - execute EFI boot manager |
d6b21894 | 323 | * |
d6b21894 | 324 | * Return: status code |
d6b21894 | 325 | */ |
7e92db81 | 326 | static int do_efibootmgr(void) |
cc999d58 | 327 | { |
6b95b38c | 328 | efi_handle_t handle; |
d6b21894 AT |
329 | efi_status_t ret; |
330 | ||
6b95b38c AT |
331 | ret = efi_bootmgr_load(&handle); |
332 | if (ret != EFI_SUCCESS) { | |
333 | printf("EFI boot manager: Cannot load any image\n"); | |
334 | return CMD_RET_FAILURE; | |
335 | } | |
cc999d58 | 336 | |
6b95b38c | 337 | ret = do_bootefi_exec(handle); |
cc999d58 | 338 | |
d6b21894 | 339 | if (ret != EFI_SUCCESS) |
6b95b38c | 340 | return CMD_RET_FAILURE; |
cc999d58 | 341 | |
6b95b38c | 342 | return CMD_RET_SUCCESS; |
cc999d58 AT |
343 | } |
344 | ||
e2e4098e | 345 | /* |
7e92db81 HS |
346 | * do_bootefi_image() - execute EFI binary |
347 | * | |
348 | * Set up memory image for the binary to be loaded, prepare device path, and | |
349 | * then call do_bootefi_exec() to execute it. | |
e2e4098e AT |
350 | * |
351 | * @image_opt: string of image start address | |
e2e4098e | 352 | * Return: status code |
e2e4098e | 353 | */ |
7e92db81 | 354 | static int do_bootefi_image(const char *image_opt) |
e2e4098e | 355 | { |
6b95b38c AT |
356 | void *image_buf; |
357 | struct efi_device_path *device_path, *image_path; | |
358 | struct efi_device_path *file_path = NULL; | |
359 | unsigned long addr, size; | |
360 | const char *size_str; | |
361 | efi_handle_t mem_handle = NULL, handle; | |
e2e4098e AT |
362 | efi_status_t ret; |
363 | ||
e2e4098e AT |
364 | #ifdef CONFIG_CMD_BOOTEFI_HELLO |
365 | if (!strcmp(image_opt, "hello")) { | |
366 | char *saddr; | |
e2e4098e AT |
367 | |
368 | saddr = env_get("loadaddr"); | |
6b95b38c AT |
369 | size = __efi_helloworld_end - __efi_helloworld_begin; |
370 | ||
e2e4098e AT |
371 | if (saddr) |
372 | addr = simple_strtoul(saddr, NULL, 16); | |
373 | else | |
374 | addr = CONFIG_SYS_LOAD_ADDR; | |
6b95b38c AT |
375 | |
376 | image_buf = map_sysmem(addr, size); | |
377 | memcpy(image_buf, __efi_helloworld_begin, size); | |
378 | ||
379 | device_path = NULL; | |
380 | image_path = NULL; | |
e2e4098e AT |
381 | } else |
382 | #endif | |
383 | { | |
6b95b38c AT |
384 | size_str = env_get("filesize"); |
385 | if (size_str) | |
386 | size = simple_strtoul(size_str, NULL, 16); | |
387 | else | |
388 | size = 0; | |
389 | ||
e2e4098e AT |
390 | addr = simple_strtoul(image_opt, NULL, 16); |
391 | /* Check that a numeric value was passed */ | |
392 | if (!addr && *image_opt != '0') | |
393 | return CMD_RET_USAGE; | |
6b95b38c AT |
394 | |
395 | image_buf = map_sysmem(addr, size); | |
396 | ||
397 | device_path = bootefi_device_path; | |
398 | image_path = bootefi_image_path; | |
e2e4098e AT |
399 | } |
400 | ||
6b95b38c AT |
401 | if (!device_path && !image_path) { |
402 | /* | |
403 | * Special case for efi payload not loaded from disk, | |
404 | * such as 'bootefi hello' or for example payload | |
405 | * loaded directly into memory via JTAG, etc: | |
406 | */ | |
407 | file_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, | |
408 | (uintptr_t)image_buf, size); | |
409 | /* | |
410 | * Make sure that device for device_path exist | |
411 | * in load_image(). Otherwise, shell and grub will fail. | |
412 | */ | |
413 | ret = efi_create_handle(&mem_handle); | |
414 | if (ret != EFI_SUCCESS) | |
415 | goto out; | |
416 | ||
417 | ret = efi_add_protocol(mem_handle, &efi_guid_device_path, | |
418 | file_path); | |
419 | if (ret != EFI_SUCCESS) | |
420 | goto out; | |
421 | } else { | |
422 | assert(device_path && image_path); | |
423 | file_path = efi_dp_append(device_path, image_path); | |
424 | } | |
425 | ||
426 | ret = EFI_CALL(efi_load_image(false, efi_root, | |
427 | file_path, image_buf, size, &handle)); | |
428 | if (ret != EFI_SUCCESS) | |
429 | goto out; | |
430 | ||
431 | ret = do_bootefi_exec(handle); | |
6b95b38c AT |
432 | |
433 | out: | |
434 | if (mem_handle) | |
435 | efi_delete_handle(mem_handle); | |
436 | if (file_path) | |
437 | efi_free_pool(file_path); | |
e2e4098e AT |
438 | |
439 | if (ret != EFI_SUCCESS) | |
440 | return CMD_RET_FAILURE; | |
6b95b38c AT |
441 | |
442 | return CMD_RET_SUCCESS; | |
e2e4098e AT |
443 | } |
444 | ||
d9717eae | 445 | #ifdef CONFIG_CMD_BOOTEFI_SELFTEST |
3fc2b163 AT |
446 | static efi_status_t bootefi_run_prepare(const char *load_options_path, |
447 | struct efi_device_path *device_path, | |
448 | struct efi_device_path *image_path, | |
449 | struct efi_loaded_image_obj **image_objp, | |
450 | struct efi_loaded_image **loaded_image_infop) | |
451 | { | |
452 | efi_status_t ret; | |
453 | ||
454 | ret = efi_setup_loaded_image(device_path, image_path, image_objp, | |
455 | loaded_image_infop); | |
456 | if (ret != EFI_SUCCESS) | |
457 | return ret; | |
458 | ||
459 | /* Transfer environment variable as load options */ | |
460 | return set_load_options((efi_handle_t)*image_objp, load_options_path); | |
461 | } | |
462 | ||
d9717eae SG |
463 | /** |
464 | * bootefi_test_prepare() - prepare to run an EFI test | |
465 | * | |
1504bb0d | 466 | * Prepare to run a test as if it were provided by a loaded image. |
d9717eae | 467 | * |
1504bb0d HS |
468 | * @image_objp: pointer to be set to the loaded image handle |
469 | * @loaded_image_infop: pointer to be set to the loaded image protocol | |
470 | * @path: dummy file path used to construct the device path | |
471 | * set in the loaded image protocol | |
472 | * @load_options_path: name of a U-Boot environment variable. Its value is | |
473 | * set as load options in the loaded image protocol. | |
474 | * Return: status code | |
d9717eae SG |
475 | */ |
476 | static efi_status_t bootefi_test_prepare | |
477 | (struct efi_loaded_image_obj **image_objp, | |
1504bb0d HS |
478 | struct efi_loaded_image **loaded_image_infop, const char *path, |
479 | const char *load_options_path) | |
d9717eae | 480 | { |
1504bb0d HS |
481 | efi_status_t ret; |
482 | ||
d9717eae | 483 | /* Construct a dummy device path */ |
1504bb0d | 484 | bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, 0, 0); |
d9717eae SG |
485 | if (!bootefi_device_path) |
486 | return EFI_OUT_OF_RESOURCES; | |
1504bb0d | 487 | |
d9717eae | 488 | bootefi_image_path = efi_dp_from_file(NULL, 0, path); |
1504bb0d HS |
489 | if (!bootefi_image_path) { |
490 | ret = EFI_OUT_OF_RESOURCES; | |
491 | goto failure; | |
492 | } | |
493 | ||
494 | ret = bootefi_run_prepare(load_options_path, bootefi_device_path, | |
495 | bootefi_image_path, image_objp, | |
496 | loaded_image_infop); | |
497 | if (ret == EFI_SUCCESS) | |
498 | return ret; | |
d9717eae | 499 | |
1504bb0d HS |
500 | efi_free_pool(bootefi_image_path); |
501 | bootefi_image_path = NULL; | |
502 | failure: | |
503 | efi_free_pool(bootefi_device_path); | |
504 | bootefi_device_path = NULL; | |
505 | return ret; | |
d9717eae SG |
506 | } |
507 | ||
3fc2b163 AT |
508 | /** |
509 | * bootefi_run_finish() - finish up after running an EFI test | |
510 | * | |
511 | * @loaded_image_info: Pointer to a struct which holds the loaded image info | |
512 | * @image_obj: Pointer to a struct which holds the loaded image object | |
513 | */ | |
514 | static void bootefi_run_finish(struct efi_loaded_image_obj *image_obj, | |
515 | struct efi_loaded_image *loaded_image_info) | |
516 | { | |
517 | efi_restore_gd(); | |
518 | free(loaded_image_info->load_options); | |
519 | efi_delete_handle(&image_obj->header); | |
520 | } | |
521 | ||
522 | /** | |
7e92db81 | 523 | * do_efi_selftest() - execute EFI selftest |
3fc2b163 | 524 | * |
3fc2b163 | 525 | * Return: status code |
3fc2b163 | 526 | */ |
7e92db81 | 527 | static int do_efi_selftest(void) |
3fc2b163 AT |
528 | { |
529 | struct efi_loaded_image_obj *image_obj; | |
530 | struct efi_loaded_image *loaded_image_info; | |
531 | efi_status_t ret; | |
532 | ||
3fc2b163 AT |
533 | ret = bootefi_test_prepare(&image_obj, &loaded_image_info, |
534 | "\\selftest", "efi_selftest"); | |
535 | if (ret != EFI_SUCCESS) | |
536 | return CMD_RET_FAILURE; | |
537 | ||
538 | /* Execute the test */ | |
539 | ret = EFI_CALL(efi_selftest(&image_obj->header, &systab)); | |
540 | bootefi_run_finish(image_obj, loaded_image_info); | |
541 | ||
542 | return ret != EFI_SUCCESS; | |
543 | } | |
d9717eae SG |
544 | #endif /* CONFIG_CMD_BOOTEFI_SELFTEST */ |
545 | ||
7e92db81 HS |
546 | /** |
547 | * do_bootefi() - execute `bootefi` command | |
548 | * | |
549 | * @cmdtp: table entry describing command | |
550 | * @flag: bitmap indicating how the command was invoked | |
551 | * @argc: number of arguments | |
552 | * @argv: command line arguments | |
553 | * Return: status code | |
554 | */ | |
b9939336 AG |
555 | static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
556 | { | |
7e92db81 HS |
557 | efi_status_t ret; |
558 | ||
3fc2b163 AT |
559 | if (argc < 2) |
560 | return CMD_RET_USAGE; | |
d6b21894 | 561 | |
7e92db81 HS |
562 | /* Initialize EFI drivers */ |
563 | ret = efi_init_obj_list(); | |
564 | if (ret != EFI_SUCCESS) { | |
565 | printf("Error: Cannot initialize UEFI sub-system, r = %lu\n", | |
566 | ret & ~EFI_ERROR_MASK); | |
567 | return CMD_RET_FAILURE; | |
568 | } | |
569 | ||
570 | ret = efi_install_fdt(argc > 2 ? argv[2] : NULL); | |
571 | if (ret == EFI_INVALID_PARAMETER) | |
572 | return CMD_RET_USAGE; | |
573 | else if (ret != EFI_SUCCESS) | |
574 | return CMD_RET_FAILURE; | |
575 | ||
d6b21894 | 576 | if (!strcmp(argv[1], "bootmgr")) |
7e92db81 | 577 | return do_efibootmgr(); |
3fc2b163 AT |
578 | #ifdef CONFIG_CMD_BOOTEFI_SELFTEST |
579 | else if (!strcmp(argv[1], "selftest")) | |
7e92db81 | 580 | return do_efi_selftest(); |
3fc2b163 AT |
581 | #endif |
582 | ||
7e92db81 | 583 | return do_bootefi_image(argv[1]); |
b9939336 AG |
584 | } |
585 | ||
586 | #ifdef CONFIG_SYS_LONGHELP | |
587 | static char bootefi_help_text[] = | |
1c39809b AG |
588 | "<image address> [fdt address]\n" |
589 | " - boot EFI payload stored at address <image address>.\n" | |
590 | " If specified, the device tree located at <fdt address> gets\n" | |
c7ae3dfd SG |
591 | " exposed as EFI configuration table.\n" |
592 | #ifdef CONFIG_CMD_BOOTEFI_HELLO | |
623b3a57 HS |
593 | "bootefi hello\n" |
594 | " - boot a sample Hello World application stored within U-Boot\n" | |
595 | #endif | |
596 | #ifdef CONFIG_CMD_BOOTEFI_SELFTEST | |
bc4f9133 | 597 | "bootefi selftest [fdt address]\n" |
623b3a57 | 598 | " - boot an EFI selftest application stored within U-Boot\n" |
d78e40d6 HS |
599 | " Use environment variable efi_selftest to select a single test.\n" |
600 | " Use 'setenv efi_selftest list' to enumerate all tests.\n" | |
c7ae3dfd | 601 | #endif |
6b95b38c | 602 | "bootefi bootmgr [fdt address]\n" |
9975fe96 RC |
603 | " - load and boot EFI payload based on BootOrder/BootXXXX variables.\n" |
604 | "\n" | |
605 | " If specified, the device tree located at <fdt address> gets\n" | |
606 | " exposed as EFI configuration table.\n"; | |
b9939336 AG |
607 | #endif |
608 | ||
609 | U_BOOT_CMD( | |
1c39809b | 610 | bootefi, 3, 0, do_bootefi, |
92dfd922 | 611 | "Boots an EFI payload from memory", |
b9939336 AG |
612 | bootefi_help_text |
613 | ); | |
0f4060eb | 614 | |
95c5553e RC |
615 | void efi_set_bootdev(const char *dev, const char *devnr, const char *path) |
616 | { | |
f1589ffb AT |
617 | struct efi_device_path *device, *image; |
618 | efi_status_t ret; | |
f9d334bd | 619 | |
79276eb2 HS |
620 | /* efi_set_bootdev is typically called repeatedly, recover memory */ |
621 | efi_free_pool(bootefi_device_path); | |
622 | efi_free_pool(bootefi_image_path); | |
9975fe96 | 623 | |
f1589ffb AT |
624 | ret = efi_dp_from_name(dev, devnr, path, &device, &image); |
625 | if (ret == EFI_SUCCESS) { | |
626 | bootefi_device_path = device; | |
6b95b38c AT |
627 | if (image) { |
628 | /* FIXME: image should not contain device */ | |
629 | struct efi_device_path *image_tmp = image; | |
630 | ||
631 | efi_dp_split_file_path(image, &device, &image); | |
632 | efi_free_pool(image_tmp); | |
633 | } | |
f1589ffb | 634 | bootefi_image_path = image; |
49271666 | 635 | } else { |
f1589ffb AT |
636 | bootefi_device_path = NULL; |
637 | bootefi_image_path = NULL; | |
49271666 | 638 | } |
0f4060eb | 639 | } |