blob: a45bfd139fc39857b9013f9bb5c5466443f436c6 [file] [log] [blame]
Tom Rinif739fcd2018-05-07 17:02:21 -04001// SPDX-License-Identifier: GPL-2.0+
Alexander Grafb9939332016-03-10 00:27:20 +01002/*
3 * EFI application loader
4 *
5 * Copyright (c) 2016 Alexander Graf
Alexander Grafb9939332016-03-10 00:27:20 +01006 */
7
8#include <common.h>
Heinrich Schuchardtf6c6df72019-01-08 18:13:06 +01009#include <charset.h>
Alexander Grafb9939332016-03-10 00:27:20 +010010#include <command.h>
Simon Glass9d922452017-05-17 17:18:03 -060011#include <dm.h>
Alexander Grafb9939332016-03-10 00:27:20 +010012#include <efi_loader.h>
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020013#include <efi_selftest.h>
Alexander Grafb9939332016-03-10 00:27:20 +010014#include <errno.h>
Masahiro Yamadab08c8c42018-03-05 01:20:11 +090015#include <linux/libfdt.h>
16#include <linux/libfdt_env.h>
Alexander Graf354264b2018-06-18 17:22:58 +020017#include <mapmem.h>
Alexander Grafad0c1a32016-04-11 23:51:01 +020018#include <memalign.h>
Simon Glasse2754582016-09-25 15:27:32 -060019#include <asm-generic/sections.h>
20#include <linux/linkage.h>
Alexander Graf0d9d5012016-04-11 16:55:26 +020021
22DECLARE_GLOBAL_DATA_PTR;
Alexander Grafb9939332016-03-10 00:27:20 +010023
Rob Clark95c55532017-09-13 18:05:33 -040024static struct efi_device_path *bootefi_image_path;
25static struct efi_device_path *bootefi_device_path;
Alexander Grafb9939332016-03-10 00:27:20 +010026
Heinrich Schuchardt810371a2019-07-14 13:00:44 +020027/**
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020028 * Set the load options of an image from an environment variable.
29 *
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090030 * @handle: the image handle
31 * @env_var: name of the environment variable
32 * Return: status code
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020033 */
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090034static efi_status_t set_load_options(efi_handle_t handle, const char *env_var)
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020035{
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090036 struct efi_loaded_image *loaded_image_info;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020037 size_t size;
38 const char *env = env_get(env_var);
Heinrich Schuchardt7086a712018-08-31 21:31:33 +020039 u16 *pos;
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090040 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;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020050
51 loaded_image_info->load_options = NULL;
52 loaded_image_info->load_options_size = 0;
53 if (!env)
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090054 goto out;
55
Heinrich Schuchardt7086a712018-08-31 21:31:33 +020056 size = utf8_utf16_strlen(env) + 1;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020057 loaded_image_info->load_options = calloc(size, sizeof(u16));
58 if (!loaded_image_info->load_options) {
59 printf("ERROR: Out of memory\n");
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090060 EFI_CALL(systab.boottime->close_protocol(handle,
61 &efi_guid_loaded_image,
62 efi_root, NULL));
63 return EFI_OUT_OF_RESOURCES;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020064 }
Heinrich Schuchardt7086a712018-08-31 21:31:33 +020065 pos = loaded_image_info->load_options;
66 utf8_utf16_strcpy(&pos, env);
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020067 loaded_image_info->load_options_size = size * 2;
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090068
69out:
70 return EFI_CALL(systab.boottime->close_protocol(handle,
71 &efi_guid_loaded_image,
72 efi_root, NULL));
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020073}
74
Heinrich Schuchardt61824952019-04-20 13:33:55 +020075#if !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
76
Simon Glass9dff4902018-08-08 03:54:30 -060077/**
78 * copy_fdt() - Copy the device tree to a new location available to EFI
79 *
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +010080 * The FDT is copied to a suitable location within the EFI memory map.
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +010081 * Additional 12 KiB are added to the space in case the device tree needs to be
Simon Glass9dff4902018-08-08 03:54:30 -060082 * expanded later with fdt_open_into().
83 *
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +010084 * @fdtp: On entry a pointer to the flattened device tree.
85 * On exit a pointer to the copy of the flattened device tree.
Heinrich Schuchardt4574d1b2018-11-12 18:55:22 +010086 * FDT start
87 * Return: status code
Simon Glass9dff4902018-08-08 03:54:30 -060088 */
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +010089static efi_status_t copy_fdt(void **fdtp)
Alexander Graf0d9d5012016-04-11 16:55:26 +020090{
Alexander Grafad0c1a32016-04-11 23:51:01 +020091 unsigned long fdt_ram_start = -1L, fdt_pages;
Simon Glass9dff4902018-08-08 03:54:30 -060092 efi_status_t ret = 0;
93 void *fdt, *new_fdt;
Alexander Grafad0c1a32016-04-11 23:51:01 +020094 u64 new_fdt_addr;
Simon Glass9dff4902018-08-08 03:54:30 -060095 uint fdt_size;
Alexander Grafad0c1a32016-04-11 23:51:01 +020096 int i;
Alexander Graf0d9d5012016-04-11 16:55:26 +020097
Simon Glass9dff4902018-08-08 03:54:30 -060098 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;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200101
Alexander Grafad0c1a32016-04-11 23:51:01 +0200102 if (!ram_size)
103 continue;
104
105 if (ram_start < fdt_ram_start)
106 fdt_ram_start = ram_start;
107 }
108
Simon Glassbc9a6382018-06-18 08:08:25 -0600109 /*
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100110 * Give us at least 12 KiB of breathing room in case the device tree
111 * needs to be expanded later.
Simon Glassbc9a6382018-06-18 08:08:25 -0600112 */
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100113 fdt = *fdtp;
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100114 fdt_pages = efi_size_in_pages(fdt_totalsize(fdt) + 0x3000);
115 fdt_size = fdt_pages << EFI_PAGE_SHIFT;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200116
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100117 /*
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);
Simon Glass9dff4902018-08-08 03:54:30 -0600123 ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
Ilias Apalodimas29361ec2019-04-12 21:26:28 +0300124 EFI_BOOT_SERVICES_DATA, fdt_pages,
Simon Glass9dff4902018-08-08 03:54:30 -0600125 &new_fdt_addr);
126 if (ret != EFI_SUCCESS) {
Alexander Grafad0c1a32016-04-11 23:51:01 +0200127 /* If we can't put it there, put it somewhere */
xypron.glpk@gmx.dea44bffc2017-08-11 21:19:25 +0200128 new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size);
Simon Glass9dff4902018-08-08 03:54:30 -0600129 ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
Ilias Apalodimas29361ec2019-04-12 21:26:28 +0300130 EFI_BOOT_SERVICES_DATA, fdt_pages,
Simon Glass9dff4902018-08-08 03:54:30 -0600131 &new_fdt_addr);
132 if (ret != EFI_SUCCESS) {
Alexander Graf85a6e9b2017-07-03 13:32:35 +0200133 printf("ERROR: Failed to reserve space for FDT\n");
Simon Glass9dff4902018-08-08 03:54:30 -0600134 goto done;
Alexander Graf85a6e9b2017-07-03 13:32:35 +0200135 }
Alexander Grafad0c1a32016-04-11 23:51:01 +0200136 }
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100137 new_fdt = (void *)(uintptr_t)new_fdt_addr;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200138 memcpy(new_fdt, fdt, fdt_totalsize(fdt));
139 fdt_set_totalsize(new_fdt, fdt_size);
140
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100141 *fdtp = (void *)(uintptr_t)new_fdt_addr;
Simon Glass9dff4902018-08-08 03:54:30 -0600142done:
143 return ret;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200144}
145
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200146/**
Simon Glass416e07e2018-06-18 08:08:28 -0600147 * 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 */
155static void efi_carve_out_dt_rsv(void *fdt)
Alexander Graf806d2fa2018-04-06 09:40:51 +0200156{
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
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100167 /* Convert from sandbox address space. */
168 addr = (uintptr_t)map_sysmem(addr, 0);
169
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100170 pages = efi_size_in_pages(size + (addr & EFI_PAGE_MASK));
Heinrich Schuchardt23fd84b2018-11-12 18:55:23 +0100171 addr &= ~EFI_PAGE_MASK;
Bryan O'Donoghueb225c922019-07-15 12:00:39 +0100172 if (efi_add_memory_map(addr, pages, EFI_RESERVED_MEMORY_TYPE,
173 false) != EFI_SUCCESS)
Simon Glass416e07e2018-06-18 08:08:28 -0600174 printf("FDT memrsv map %d: Failed to add to map\n", i);
Alexander Graf806d2fa2018-04-06 09:40:51 +0200175 }
Alexander Graf806d2fa2018-04-06 09:40:51 +0200176}
177
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900178/**
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200179 * get_config_table() - get configuration table
180 *
181 * @guid: GUID of the configuration table
182 * Return: pointer to configuration table or NULL
183 */
184static 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
197/**
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900198 * efi_install_fdt() - install fdt passed by a command argument
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200199 *
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 *
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900207 * @fdt_opt: pointer to argument
208 * Return: status code
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900209 */
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900210static efi_status_t efi_install_fdt(const char *fdt_opt)
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900211{
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200212 /*
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
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900222 unsigned long fdt_addr;
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900223 void *fdt;
224 bootm_headers_t img = { 0 };
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900225 efi_status_t ret;
226
227 if (fdt_opt) {
228 fdt_addr = simple_strtoul(fdt_opt, NULL, 16);
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200229 if (!fdt_addr)
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900230 return EFI_INVALID_PARAMETER;
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200231 } 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;
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900240 }
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200241 fdt_addr = simple_strtoul(fdt_opt, NULL, 16);
242 if (!fdt_addr) {
243 printf("ERROR: invalid $fdtcontroladdr\n");
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900244 return EFI_LOAD_ERROR;
245 }
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900246 }
247
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200248 /* 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 }
254
255 /* Create memory reservations as indicated by the device tree */
256 efi_carve_out_dt_rsv(fdt);
257
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 }
264
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;
275 }
276#endif /* GENERATE_ACPI_TABLE */
277
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900278 return EFI_SUCCESS;
279}
280
Simon Glass5e2f0392018-11-25 20:14:39 -0700281/**
Heinrich Schuchardtc9828742018-09-23 17:21:51 +0200282 * do_bootefi_exec() - execute EFI binary
283 *
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900284 * @handle: handle of loaded image
Heinrich Schuchardtc9828742018-09-23 17:21:51 +0200285 * 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.
Alexander Grafb9939332016-03-10 00:27:20 +0100289 */
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900290static efi_status_t do_bootefi_exec(efi_handle_t handle)
Alexander Grafb9939332016-03-10 00:27:20 +0100291{
Heinrich Schuchardt45204b12018-03-03 15:29:01 +0100292 efi_status_t ret;
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200293 efi_uintn_t exit_data_size = 0;
294 u16 *exit_data = NULL;
Rob Clark95c55532017-09-13 18:05:33 -0400295
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900296 /* Transfer environment variable as load options */
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900297 ret = set_load_options(handle, "bootargs");
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900298 if (ret != EFI_SUCCESS)
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900299 return ret;
Rob Clarkbf192732017-10-10 08:23:06 -0400300
Alexander Grafb9939332016-03-10 00:27:20 +0100301 /* Call our payload! */
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200302 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 }
Rob Clark95c55532017-09-13 18:05:33 -0400308
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900309 efi_restore_gd();
Simon Glass5e2f0392018-11-25 20:14:39 -0700310
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900311 /*
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 */
Rob Clark95c55532017-09-13 18:05:33 -0400317
318 return ret;
Alexander Grafb9939332016-03-10 00:27:20 +0100319}
320
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900321/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200322 * do_efibootmgr() - execute EFI boot manager
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900323 *
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900324 * Return: status code
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900325 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200326static int do_efibootmgr(void)
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900327{
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900328 efi_handle_t handle;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900329 efi_status_t ret;
330
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900331 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 }
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900336
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900337 ret = do_bootefi_exec(handle);
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900338
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900339 if (ret != EFI_SUCCESS)
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900340 return CMD_RET_FAILURE;
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900341
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900342 return CMD_RET_SUCCESS;
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900343}
344
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200345/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200346 * 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.
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900350 *
351 * @image_opt: string of image start address
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900352 * Return: status code
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900353 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200354static int do_bootefi_image(const char *image_opt)
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900355{
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900356 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;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900362 efi_status_t ret;
363
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900364#ifdef CONFIG_CMD_BOOTEFI_HELLO
365 if (!strcmp(image_opt, "hello")) {
366 char *saddr;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900367
368 saddr = env_get("loadaddr");
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900369 size = __efi_helloworld_end - __efi_helloworld_begin;
370
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900371 if (saddr)
372 addr = simple_strtoul(saddr, NULL, 16);
373 else
374 addr = CONFIG_SYS_LOAD_ADDR;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900375
376 image_buf = map_sysmem(addr, size);
377 memcpy(image_buf, __efi_helloworld_begin, size);
378
379 device_path = NULL;
380 image_path = NULL;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900381 } else
382#endif
383 {
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900384 size_str = env_get("filesize");
385 if (size_str)
386 size = simple_strtoul(size_str, NULL, 16);
387 else
388 size = 0;
389
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900390 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;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900394
395 image_buf = map_sysmem(addr, size);
396
397 device_path = bootefi_device_path;
398 image_path = bootefi_image_path;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900399 }
400
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900401 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);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900432
433out:
434 if (mem_handle)
435 efi_delete_handle(mem_handle);
436 if (file_path)
437 efi_free_pool(file_path);
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900438
439 if (ret != EFI_SUCCESS)
440 return CMD_RET_FAILURE;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900441
442 return CMD_RET_SUCCESS;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900443}
444
Simon Glassd9717ea2018-11-25 20:14:37 -0700445#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900446static 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
Simon Glassd9717ea2018-11-25 20:14:37 -0700463/**
464 * bootefi_test_prepare() - prepare to run an EFI test
465 *
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100466 * Prepare to run a test as if it were provided by a loaded image.
Simon Glassd9717ea2018-11-25 20:14:37 -0700467 *
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100468 * @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
Simon Glassd9717ea2018-11-25 20:14:37 -0700475 */
476static efi_status_t bootefi_test_prepare
477 (struct efi_loaded_image_obj **image_objp,
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100478 struct efi_loaded_image **loaded_image_infop, const char *path,
479 const char *load_options_path)
Simon Glassd9717ea2018-11-25 20:14:37 -0700480{
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100481 efi_status_t ret;
482
Simon Glassd9717ea2018-11-25 20:14:37 -0700483 /* Construct a dummy device path */
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100484 bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, 0, 0);
Simon Glassd9717ea2018-11-25 20:14:37 -0700485 if (!bootefi_device_path)
486 return EFI_OUT_OF_RESOURCES;
Simon Glassd9717ea2018-11-25 20:14:37 -0700487
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100488 bootefi_image_path = efi_dp_from_file(NULL, 0, path);
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;
499
500 efi_free_pool(bootefi_image_path);
501 bootefi_image_path = NULL;
502failure:
503 efi_free_pool(bootefi_device_path);
504 bootefi_device_path = NULL;
505 return ret;
Simon Glassd9717ea2018-11-25 20:14:37 -0700506}
507
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900508/**
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 */
514static 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/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200523 * do_efi_selftest() - execute EFI selftest
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900524 *
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900525 * Return: status code
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900526 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200527static int do_efi_selftest(void)
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900528{
529 struct efi_loaded_image_obj *image_obj;
530 struct efi_loaded_image *loaded_image_info;
531 efi_status_t ret;
532
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900533 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}
Simon Glassd9717ea2018-11-25 20:14:37 -0700544#endif /* CONFIG_CMD_BOOTEFI_SELFTEST */
545
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200546/**
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 */
Alexander Grafb9939332016-03-10 00:27:20 +0100555static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
556{
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200557 efi_status_t ret;
558
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900559 if (argc < 2)
560 return CMD_RET_USAGE;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900561
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200562 /* 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
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900576 if (!strcmp(argv[1], "bootmgr"))
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200577 return do_efibootmgr();
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900578#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
579 else if (!strcmp(argv[1], "selftest"))
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200580 return do_efi_selftest();
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900581#endif
582
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200583 return do_bootefi_image(argv[1]);
Alexander Grafb9939332016-03-10 00:27:20 +0100584}
585
586#ifdef CONFIG_SYS_LONGHELP
587static char bootefi_help_text[] =
Alexander Graf1c398092016-04-14 16:07:53 +0200588 "<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"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700591 " exposed as EFI configuration table.\n"
592#ifdef CONFIG_CMD_BOOTEFI_HELLO
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200593 "bootefi hello\n"
594 " - boot a sample Hello World application stored within U-Boot\n"
595#endif
596#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100597 "bootefi selftest [fdt address]\n"
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200598 " - boot an EFI selftest application stored within U-Boot\n"
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200599 " Use environment variable efi_selftest to select a single test.\n"
600 " Use 'setenv efi_selftest list' to enumerate all tests.\n"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700601#endif
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900602 "bootefi bootmgr [fdt address]\n"
Rob Clark9975fe92017-09-13 18:05:38 -0400603 " - 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";
Alexander Grafb9939332016-03-10 00:27:20 +0100607#endif
608
609U_BOOT_CMD(
Alexander Graf1c398092016-04-14 16:07:53 +0200610 bootefi, 3, 0, do_bootefi,
Sergey Kubushyn92dfd922016-06-07 11:14:31 -0700611 "Boots an EFI payload from memory",
Alexander Grafb9939332016-03-10 00:27:20 +0100612 bootefi_help_text
613);
Alexander Graf0f4060e2016-03-04 01:10:14 +0100614
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200615/**
616 * efi_set_bootdev() - set boot device
617 *
618 * This function is called when a file is loaded, e.g. via the 'load' command.
619 * We use the path to this file to inform the UEFI binary about the boot device.
620 *
621 * @dev: device, e.g. "MMC"
622 * @devnr: number of the device, e.g. "1:2"
623 * @path: path to file loaded
624 */
Alexander Grafc07ad7c2016-04-11 16:16:19 +0200625void efi_set_bootdev(const char *dev, const char *devnr, const char *path)
Alexander Graf0f4060e2016-03-04 01:10:14 +0100626{
AKASHI Takahirof1589ff2018-10-17 16:32:03 +0900627 struct efi_device_path *device, *image;
628 efi_status_t ret;
Alexander Graf0f4060e2016-03-04 01:10:14 +0100629
Heinrich Schuchardt79276eb2018-09-16 07:20:21 +0200630 /* efi_set_bootdev is typically called repeatedly, recover memory */
631 efi_free_pool(bootefi_device_path);
632 efi_free_pool(bootefi_image_path);
Heinrich Schuchardt79276eb2018-09-16 07:20:21 +0200633
AKASHI Takahirof1589ff2018-10-17 16:32:03 +0900634 ret = efi_dp_from_name(dev, devnr, path, &device, &image);
635 if (ret == EFI_SUCCESS) {
636 bootefi_device_path = device;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900637 if (image) {
638 /* FIXME: image should not contain device */
639 struct efi_device_path *image_tmp = image;
640
641 efi_dp_split_file_path(image, &device, &image);
642 efi_free_pool(image_tmp);
643 }
AKASHI Takahirof1589ff2018-10-17 16:32:03 +0900644 bootefi_image_path = image;
Rob Clark95c55532017-09-13 18:05:33 -0400645 } else {
AKASHI Takahirof1589ff2018-10-17 16:32:03 +0900646 bootefi_device_path = NULL;
647 bootefi_image_path = NULL;
Alexander Graff9d334b2016-08-05 14:49:53 +0200648 }
Alexander Graf0f4060e2016-03-04 01:10:14 +0100649}