blob: 8aa15a64c83617eb25de641e2ebddd82803e9338 [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
Heinrich Schuchardtc0018372020-07-17 20:21:00 +02008#define LOG_CATEGORY LOGC_EFI
9
Alexander Grafb9939332016-03-10 00:27:20 +010010#include <common.h>
Heinrich Schuchardt82d01f02021-01-24 14:34:12 +000011#include <bootm.h>
Heinrich Schuchardtf6c6df72019-01-08 18:13:06 +010012#include <charset.h>
Alexander Grafb9939332016-03-10 00:27:20 +010013#include <command.h>
Simon Glass9d922452017-05-17 17:18:03 -060014#include <dm.h>
Alexander Grafb9939332016-03-10 00:27:20 +010015#include <efi_loader.h>
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020016#include <efi_selftest.h>
Simon Glass7b51b572019-08-01 09:46:52 -060017#include <env.h>
Alexander Grafb9939332016-03-10 00:27:20 +010018#include <errno.h>
Simon Glass4d72caa2020-05-10 11:40:01 -060019#include <image.h>
Heinrich Schuchardtc0018372020-07-17 20:21:00 +020020#include <log.h>
Simon Glass336d4612020-02-03 07:36:16 -070021#include <malloc.h>
Simon Glass401d1c42020-10-30 21:38:53 -060022#include <asm/global_data.h>
Masahiro Yamadab08c8c42018-03-05 01:20:11 +090023#include <linux/libfdt.h>
24#include <linux/libfdt_env.h>
Alexander Graf354264b2018-06-18 17:22:58 +020025#include <mapmem.h>
Alexander Grafad0c1a32016-04-11 23:51:01 +020026#include <memalign.h>
Simon Glasse2754582016-09-25 15:27:32 -060027#include <asm-generic/sections.h>
28#include <linux/linkage.h>
Alexander Graf0d9d5012016-04-11 16:55:26 +020029
30DECLARE_GLOBAL_DATA_PTR;
Alexander Grafb9939332016-03-10 00:27:20 +010031
Rob Clark95c55532017-09-13 18:05:33 -040032static struct efi_device_path *bootefi_image_path;
33static struct efi_device_path *bootefi_device_path;
Heinrich Schuchardt5f595182021-01-12 12:46:24 +010034static void *image_addr;
35static size_t image_size;
36
37/**
Rui Miguel Silvabfef72e2022-05-11 10:55:40 +010038 * efi_get_image_parameters() - return image parameters
39 *
40 * @img_addr: address of loaded image in memory
41 * @img_size: size of loaded image
42 */
43void efi_get_image_parameters(void **img_addr, size_t *img_size)
44{
45 *img_addr = image_addr;
46 *img_size = image_size;
47}
48
49/**
Heinrich Schuchardt5f595182021-01-12 12:46:24 +010050 * efi_clear_bootdev() - clear boot device
51 */
52static void efi_clear_bootdev(void)
53{
54 efi_free_pool(bootefi_device_path);
55 efi_free_pool(bootefi_image_path);
56 bootefi_device_path = NULL;
57 bootefi_image_path = NULL;
58 image_addr = NULL;
59 image_size = 0;
60}
61
62/**
63 * efi_set_bootdev() - set boot device
64 *
65 * This function is called when a file is loaded, e.g. via the 'load' command.
66 * We use the path to this file to inform the UEFI binary about the boot device.
67 *
68 * @dev: device, e.g. "MMC"
69 * @devnr: number of the device, e.g. "1:2"
70 * @path: path to file loaded
71 * @buffer: buffer with file loaded
72 * @buffer_size: size of file loaded
73 */
74void efi_set_bootdev(const char *dev, const char *devnr, const char *path,
75 void *buffer, size_t buffer_size)
76{
77 struct efi_device_path *device, *image;
78 efi_status_t ret;
79
Simon Glassd837cb12022-01-29 14:58:37 -070080 log_debug("dev=%s, devnr=%s, path=%s, buffer=%p, size=%zx\n", dev,
81 devnr, path, buffer, buffer_size);
82
Heinrich Schuchardt5f595182021-01-12 12:46:24 +010083 /* Forget overwritten image */
84 if (buffer + buffer_size >= image_addr &&
85 image_addr + image_size >= buffer)
86 efi_clear_bootdev();
87
88 /* Remember only PE-COFF and FIT images */
89 if (efi_check_pe(buffer, buffer_size, NULL) != EFI_SUCCESS) {
Simon Glassd837cb12022-01-29 14:58:37 -070090 if (IS_ENABLED(CONFIG_FIT) &&
91 !fit_check_format(buffer, IMAGE_SIZE_INVAL)) {
92 /*
93 * FIT images of type EFI_OS are started via command
94 * bootm. We should not use their boot device with the
95 * bootefi command.
96 */
97 buffer = 0;
98 buffer_size = 0;
99 } else {
100 log_debug("- not remembering image\n");
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100101 return;
Simon Glassd837cb12022-01-29 14:58:37 -0700102 }
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100103 }
104
105 /* efi_set_bootdev() is typically called repeatedly, recover memory */
106 efi_clear_bootdev();
107
108 image_addr = buffer;
109 image_size = buffer_size;
110
111 ret = efi_dp_from_name(dev, devnr, path, &device, &image);
112 if (ret == EFI_SUCCESS) {
113 bootefi_device_path = device;
114 if (image) {
115 /* FIXME: image should not contain device */
116 struct efi_device_path *image_tmp = image;
117
118 efi_dp_split_file_path(image, &device, &image);
119 efi_free_pool(image_tmp);
120 }
121 bootefi_image_path = image;
Heinrich Schuchardt868353d2022-07-10 15:46:57 +0200122 log_debug("- boot device %pD\n", device);
Simon Glassd837cb12022-01-29 14:58:37 -0700123 if (image)
Heinrich Schuchardt868353d2022-07-10 15:46:57 +0200124 log_debug("- image %pD\n", image);
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100125 } else {
Simon Glassd837cb12022-01-29 14:58:37 -0700126 log_debug("- efi_dp_from_name() failed, err=%lx\n", ret);
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100127 efi_clear_bootdev();
128 }
129}
Alexander Grafb9939332016-03-10 00:27:20 +0100130
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200131/**
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200132 * efi_env_set_load_options() - set load options from environment variable
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200133 *
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100134 * @handle: the image handle
135 * @env_var: name of the environment variable
136 * @load_options: pointer to load options (output)
137 * Return: status code
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200138 */
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200139static efi_status_t efi_env_set_load_options(efi_handle_t handle,
140 const char *env_var,
141 u16 **load_options)
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200142{
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200143 const char *env = env_get(env_var);
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200144 size_t size;
Heinrich Schuchardt7086a712018-08-31 21:31:33 +0200145 u16 *pos;
AKASHI Takahirodefa7b82019-04-19 12:22:28 +0900146 efi_status_t ret;
147
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100148 *load_options = NULL;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200149 if (!env)
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200150 return EFI_SUCCESS;
151 size = sizeof(u16) * (utf8_utf16_strlen(env) + 1);
152 pos = calloc(size, 1);
153 if (!pos)
AKASHI Takahirodefa7b82019-04-19 12:22:28 +0900154 return EFI_OUT_OF_RESOURCES;
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100155 *load_options = pos;
Heinrich Schuchardt7086a712018-08-31 21:31:33 +0200156 utf8_utf16_strcpy(&pos, env);
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200157 ret = efi_set_load_options(handle, size, *load_options);
158 if (ret != EFI_SUCCESS) {
159 free(*load_options);
160 *load_options = NULL;
161 }
162 return ret;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200163}
164
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200165#if !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
166
Simon Glass9dff4902018-08-08 03:54:30 -0600167/**
168 * copy_fdt() - Copy the device tree to a new location available to EFI
169 *
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100170 * The FDT is copied to a suitable location within the EFI memory map.
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100171 * Additional 12 KiB are added to the space in case the device tree needs to be
Simon Glass9dff4902018-08-08 03:54:30 -0600172 * expanded later with fdt_open_into().
173 *
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100174 * @fdtp: On entry a pointer to the flattened device tree.
175 * On exit a pointer to the copy of the flattened device tree.
Heinrich Schuchardt4574d1b2018-11-12 18:55:22 +0100176 * FDT start
177 * Return: status code
Simon Glass9dff4902018-08-08 03:54:30 -0600178 */
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100179static efi_status_t copy_fdt(void **fdtp)
Alexander Graf0d9d5012016-04-11 16:55:26 +0200180{
Alexander Grafad0c1a32016-04-11 23:51:01 +0200181 unsigned long fdt_ram_start = -1L, fdt_pages;
Simon Glass9dff4902018-08-08 03:54:30 -0600182 efi_status_t ret = 0;
183 void *fdt, *new_fdt;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200184 u64 new_fdt_addr;
Simon Glass9dff4902018-08-08 03:54:30 -0600185 uint fdt_size;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200186 int i;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200187
Simon Glass9dff4902018-08-08 03:54:30 -0600188 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
189 u64 ram_start = gd->bd->bi_dram[i].start;
190 u64 ram_size = gd->bd->bi_dram[i].size;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200191
Alexander Grafad0c1a32016-04-11 23:51:01 +0200192 if (!ram_size)
193 continue;
194
195 if (ram_start < fdt_ram_start)
196 fdt_ram_start = ram_start;
197 }
198
Simon Glassbc9a6382018-06-18 08:08:25 -0600199 /*
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100200 * Give us at least 12 KiB of breathing room in case the device tree
201 * needs to be expanded later.
Simon Glassbc9a6382018-06-18 08:08:25 -0600202 */
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100203 fdt = *fdtp;
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100204 fdt_pages = efi_size_in_pages(fdt_totalsize(fdt) + 0x3000);
205 fdt_size = fdt_pages << EFI_PAGE_SHIFT;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200206
Heinrich Schuchardt93e33642023-02-23 20:27:38 +0100207 ret = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES,
Heinrich Schuchardt42a426e2020-05-06 20:32:31 +0200208 EFI_ACPI_RECLAIM_MEMORY, fdt_pages,
Simon Glass9dff4902018-08-08 03:54:30 -0600209 &new_fdt_addr);
210 if (ret != EFI_SUCCESS) {
Heinrich Schuchardt93e33642023-02-23 20:27:38 +0100211 log_err("ERROR: Failed to reserve space for FDT\n");
212 goto done;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200213 }
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100214 new_fdt = (void *)(uintptr_t)new_fdt_addr;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200215 memcpy(new_fdt, fdt, fdt_totalsize(fdt));
216 fdt_set_totalsize(new_fdt, fdt_size);
217
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100218 *fdtp = (void *)(uintptr_t)new_fdt_addr;
Simon Glass9dff4902018-08-08 03:54:30 -0600219done:
220 return ret;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200221}
222
Heinrich Schuchardt4cbb2932020-08-27 12:52:20 +0200223/**
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200224 * get_config_table() - get configuration table
225 *
226 * @guid: GUID of the configuration table
227 * Return: pointer to configuration table or NULL
228 */
229static void *get_config_table(const efi_guid_t *guid)
230{
231 size_t i;
232
233 for (i = 0; i < systab.nr_tables; i++) {
234 if (!guidcmp(guid, &systab.tables[i].guid))
235 return systab.tables[i].table;
236 }
237 return NULL;
238}
239
240#endif /* !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE) */
241
242/**
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100243 * efi_install_fdt() - install device tree
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200244 *
Heinrich Schuchardt7d4d5512020-02-07 22:10:49 +0100245 * If fdt is not EFI_FDT_USE_INTERNAL, the device tree located at that memory
246 * address will will be installed as configuration table, otherwise the device
247 * tree located at the address indicated by environment variable fdt_addr or as
248 * fallback fdtcontroladdr will be used.
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200249 *
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100250 * On architectures using ACPI tables device trees shall not be installed as
251 * configuration table.
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200252 *
Heinrich Schuchardt7d4d5512020-02-07 22:10:49 +0100253 * @fdt: address of device tree or EFI_FDT_USE_INTERNAL to use the
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100254 * the hardware device tree as indicated by environment variable
255 * fdt_addr or as fallback the internal device tree as indicated by
256 * the environment variable fdtcontroladdr
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900257 * Return: status code
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900258 */
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100259efi_status_t efi_install_fdt(void *fdt)
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900260{
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200261 /*
262 * The EBBR spec requires that we have either an FDT or an ACPI table
263 * but not both.
264 */
265#if CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100266 if (fdt) {
Alexander Graf0832dd22022-02-27 13:18:56 +0100267 log_warning("WARNING: Can't have ACPI table and device tree - ignoring DT.\n");
268 return EFI_SUCCESS;
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200269 }
270#else
Simon Glassd9d7c202022-09-06 20:26:50 -0600271 struct bootm_headers img = { 0 };
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900272 efi_status_t ret;
273
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100274 if (fdt == EFI_FDT_USE_INTERNAL) {
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100275 const char *fdt_opt;
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100276 uintptr_t fdt_addr;
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100277
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200278 /* Look for device tree that is already installed */
279 if (get_config_table(&efi_guid_fdt))
280 return EFI_SUCCESS;
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100281 /* Check if there is a hardware device tree */
282 fdt_opt = env_get("fdt_addr");
283 /* Use our own device tree as fallback */
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200284 if (!fdt_opt) {
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100285 fdt_opt = env_get("fdtcontroladdr");
286 if (!fdt_opt) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200287 log_err("ERROR: need device tree\n");
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100288 return EFI_NOT_FOUND;
289 }
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900290 }
Simon Glass7e5f4602021-07-24 09:03:29 -0600291 fdt_addr = hextoul(fdt_opt, NULL);
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200292 if (!fdt_addr) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200293 log_err("ERROR: invalid $fdt_addr or $fdtcontroladdr\n");
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900294 return EFI_LOAD_ERROR;
295 }
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100296 fdt = map_sysmem(fdt_addr, 0);
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900297 }
298
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200299 /* Install device tree */
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200300 if (fdt_check_header(fdt)) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200301 log_err("ERROR: invalid device tree\n");
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200302 return EFI_LOAD_ERROR;
303 }
304
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200305 /* Prepare device tree for payload */
306 ret = copy_fdt(&fdt);
307 if (ret) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200308 log_err("ERROR: out of memory\n");
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200309 return EFI_OUT_OF_RESOURCES;
310 }
311
312 if (image_setup_libfdt(&img, fdt, 0, NULL)) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200313 log_err("ERROR: failed to process device tree\n");
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200314 return EFI_LOAD_ERROR;
315 }
316
Heinrich Schuchardtfef907b2020-03-14 10:59:34 +0100317 /* Create memory reservations as indicated by the device tree */
318 efi_carve_out_dt_rsv(fdt);
319
Ilias Apalodimasa2f14822022-01-03 14:07:37 +0200320 efi_try_purge_kaslr_seed(fdt);
321
Etienne Carriereaa2d3942023-02-16 17:29:48 +0100322 if (CONFIG_IS_ENABLED(EFI_TCG2_PROTOCOL_MEASURE_DTB)) {
323 ret = efi_tcg2_measure_dtb(fdt);
324 if (ret == EFI_SECURITY_VIOLATION) {
325 log_err("ERROR: failed to measure DTB\n");
326 return ret;
327 }
328 }
329
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200330 /* Install device tree as UEFI table */
331 ret = efi_install_configuration_table(&efi_guid_fdt, fdt);
332 if (ret != EFI_SUCCESS) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200333 log_err("ERROR: failed to install device tree\n");
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200334 return ret;
335 }
336#endif /* GENERATE_ACPI_TABLE */
337
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900338 return EFI_SUCCESS;
339}
340
Simon Glass5e2f0392018-11-25 20:14:39 -0700341/**
Heinrich Schuchardtc9828742018-09-23 17:21:51 +0200342 * do_bootefi_exec() - execute EFI binary
343 *
Heinrich Schuchardt72e1fca2020-08-15 23:10:22 +0200344 * The image indicated by @handle is started. When it returns the allocated
345 * memory for the @load_options is freed.
346 *
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900347 * @handle: handle of loaded image
Heinrich Schuchardt72e1fca2020-08-15 23:10:22 +0200348 * @load_options: load options
Heinrich Schuchardtc9828742018-09-23 17:21:51 +0200349 * Return: status code
350 *
351 * Load the EFI binary into a newly assigned memory unwinding the relocation
352 * information, install the loaded image protocol, and call the binary.
Alexander Grafb9939332016-03-10 00:27:20 +0100353 */
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200354static efi_status_t do_bootefi_exec(efi_handle_t handle, void *load_options)
Alexander Grafb9939332016-03-10 00:27:20 +0100355{
Heinrich Schuchardt45204b12018-03-03 15:29:01 +0100356 efi_status_t ret;
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200357 efi_uintn_t exit_data_size = 0;
358 u16 *exit_data = NULL;
Rob Clarkbf192732017-10-10 08:23:06 -0400359
Heinrich Schuchardt82d01f02021-01-24 14:34:12 +0000360 /* On ARM switch from EL3 or secure mode to EL2 or non-secure mode */
361 switch_to_non_secure_mode();
362
Masahisa Kojima3fa9ed92022-02-22 09:58:30 +0900363 /*
364 * The UEFI standard requires that the watchdog timer is set to five
365 * minutes when invoking an EFI boot option.
366 *
367 * Unified Extensible Firmware Interface (UEFI), version 2.7 Errata A
368 * 7.5. Miscellaneous Boot Services - EFI_BOOT_SERVICES.SetWatchdogTimer
369 */
370 ret = efi_set_watchdog(300);
371 if (ret != EFI_SUCCESS) {
372 log_err("ERROR: Failed to set watchdog timer\n");
373 goto out;
374 }
375
Alexander Grafb9939332016-03-10 00:27:20 +0100376 /* Call our payload! */
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200377 ret = EFI_CALL(efi_start_image(handle, &exit_data_size, &exit_data));
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200378 if (ret != EFI_SUCCESS) {
379 log_err("## Application failed, r = %lu\n",
380 ret & ~EFI_ERROR_MASK);
381 if (exit_data) {
382 log_err("## %ls\n", exit_data);
383 efi_free_pool(exit_data);
384 }
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200385 }
Rob Clark95c55532017-09-13 18:05:33 -0400386
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900387 efi_restore_gd();
Simon Glass5e2f0392018-11-25 20:14:39 -0700388
Masahisa Kojima3fa9ed92022-02-22 09:58:30 +0900389out:
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100390 free(load_options);
Rob Clark95c55532017-09-13 18:05:33 -0400391
Ilias Apalodimas70089c12022-10-16 11:36:32 +0300392 if (IS_ENABLED(CONFIG_EFI_LOAD_FILE2_INITRD)) {
393 if (efi_initrd_deregister() != EFI_SUCCESS)
394 log_err("Failed to remove loadfile2 for initrd\n");
395 }
Ilias Apalodimas53f6a5a2021-03-17 21:55:00 +0200396
Masahisa Kojima3fa9ed92022-02-22 09:58:30 +0900397 /* Control is returned to U-Boot, disable EFI watchdog */
398 efi_set_watchdog(0);
399
Rob Clark95c55532017-09-13 18:05:33 -0400400 return ret;
Alexander Grafb9939332016-03-10 00:27:20 +0100401}
402
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900403/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200404 * do_efibootmgr() - execute EFI boot manager
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900405 *
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900406 * Return: status code
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900407 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200408static int do_efibootmgr(void)
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900409{
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900410 efi_handle_t handle;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900411 efi_status_t ret;
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200412 void *load_options;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900413
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200414 ret = efi_bootmgr_load(&handle, &load_options);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900415 if (ret != EFI_SUCCESS) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200416 log_notice("EFI boot manager: Cannot load any image\n");
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900417 return CMD_RET_FAILURE;
418 }
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900419
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200420 ret = do_bootefi_exec(handle, load_options);
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900421
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900422 if (ret != EFI_SUCCESS)
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900423 return CMD_RET_FAILURE;
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900424
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900425 return CMD_RET_SUCCESS;
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900426}
427
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200428/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200429 * do_bootefi_image() - execute EFI binary
430 *
431 * Set up memory image for the binary to be loaded, prepare device path, and
432 * then call do_bootefi_exec() to execute it.
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900433 *
Kyle Evans20589832022-04-10 16:05:55 -0500434 * @image_opt: string with image start address
435 * @size_opt: string with image size or NULL
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900436 * Return: status code
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900437 */
Kyle Evans20589832022-04-10 16:05:55 -0500438static int do_bootefi_image(const char *image_opt, const char *size_opt)
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900439{
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900440 void *image_buf;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900441 unsigned long addr, size;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900442 efi_status_t ret;
443
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900444#ifdef CONFIG_CMD_BOOTEFI_HELLO
445 if (!strcmp(image_opt, "hello")) {
Heinrich Schuchardtbb33c792021-01-12 17:44:08 +0100446 image_buf = __efi_helloworld_begin;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900447 size = __efi_helloworld_end - __efi_helloworld_begin;
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100448 efi_clear_bootdev();
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900449 } else
450#endif
451 {
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100452 addr = strtoul(image_opt, NULL, 16);
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900453 /* Check that a numeric value was passed */
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100454 if (!addr)
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900455 return CMD_RET_USAGE;
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100456 image_buf = map_sysmem(addr, 0);
457
Kyle Evans20589832022-04-10 16:05:55 -0500458 if (size_opt) {
459 size = strtoul(size_opt, NULL, 16);
460 if (!size)
461 return CMD_RET_USAGE;
462 efi_clear_bootdev();
463 } else {
464 if (image_buf != image_addr) {
465 log_err("No UEFI binary known at %s\n",
466 image_opt);
467 return CMD_RET_FAILURE;
468 }
469 size = image_size;
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100470 }
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900471 }
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100472 ret = efi_run_image(image_buf, size);
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900473
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100474 if (ret != EFI_SUCCESS)
475 return CMD_RET_FAILURE;
476
477 return CMD_RET_SUCCESS;
478}
479
480/**
481 * efi_run_image() - run loaded UEFI image
482 *
483 * @source_buffer: memory address of the UEFI image
484 * @source_size: size of the UEFI image
485 * Return: status code
486 */
487efi_status_t efi_run_image(void *source_buffer, efi_uintn_t source_size)
488{
489 efi_handle_t mem_handle = NULL, handle;
490 struct efi_device_path *file_path = NULL;
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000491 struct efi_device_path *msg_path;
Ilias Apalodimasa75e8352022-10-06 16:08:44 +0300492 efi_status_t ret, ret2;
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000493 u16 *load_options;
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100494
495 if (!bootefi_device_path || !bootefi_image_path) {
Simon Glassd837cb12022-01-29 14:58:37 -0700496 log_debug("Not loaded from disk\n");
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900497 /*
498 * Special case for efi payload not loaded from disk,
499 * such as 'bootefi hello' or for example payload
500 * loaded directly into memory via JTAG, etc:
501 */
502 file_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE,
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100503 (uintptr_t)source_buffer,
504 source_size);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900505 /*
506 * Make sure that device for device_path exist
507 * in load_image(). Otherwise, shell and grub will fail.
508 */
Ilias Apalodimasa75e8352022-10-06 16:08:44 +0300509 ret = efi_install_multiple_protocol_interfaces(&mem_handle,
510 &efi_guid_device_path,
511 file_path, NULL);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900512 if (ret != EFI_SUCCESS)
513 goto out;
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000514 msg_path = file_path;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900515 } else {
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100516 file_path = efi_dp_append(bootefi_device_path,
517 bootefi_image_path);
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000518 msg_path = bootefi_image_path;
Simon Glassd837cb12022-01-29 14:58:37 -0700519 log_debug("Loaded from disk\n");
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900520 }
521
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000522 log_info("Booting %pD\n", msg_path);
523
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100524 ret = EFI_CALL(efi_load_image(false, efi_root, file_path, source_buffer,
525 source_size, &handle));
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000526 if (ret != EFI_SUCCESS) {
527 log_err("Loading image failed\n");
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900528 goto out;
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000529 }
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200530
531 /* Transfer environment variable as load options */
532 ret = efi_env_set_load_options(handle, "bootargs", &load_options);
533 if (ret != EFI_SUCCESS)
534 goto out;
535
536 ret = do_bootefi_exec(handle, load_options);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900537
538out:
Ilias Apalodimasa75e8352022-10-06 16:08:44 +0300539 ret2 = efi_uninstall_multiple_protocol_interfaces(mem_handle,
540 &efi_guid_device_path,
541 file_path, NULL);
Heinrich Schuchardt4fe050e2020-04-20 12:44:56 +0200542 efi_free_pool(file_path);
Ilias Apalodimasa75e8352022-10-06 16:08:44 +0300543 return (ret != EFI_SUCCESS) ? ret : ret2;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900544}
545
Simon Glassd9717ea2018-11-25 20:14:37 -0700546#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900547static efi_status_t bootefi_run_prepare(const char *load_options_path,
548 struct efi_device_path *device_path,
549 struct efi_device_path *image_path,
550 struct efi_loaded_image_obj **image_objp,
551 struct efi_loaded_image **loaded_image_infop)
552{
553 efi_status_t ret;
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100554 u16 *load_options;
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900555
556 ret = efi_setup_loaded_image(device_path, image_path, image_objp,
557 loaded_image_infop);
558 if (ret != EFI_SUCCESS)
559 return ret;
560
561 /* Transfer environment variable as load options */
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200562 return efi_env_set_load_options((efi_handle_t)*image_objp,
563 load_options_path,
564 &load_options);
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900565}
566
Simon Glassd9717ea2018-11-25 20:14:37 -0700567/**
568 * bootefi_test_prepare() - prepare to run an EFI test
569 *
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100570 * Prepare to run a test as if it were provided by a loaded image.
Simon Glassd9717ea2018-11-25 20:14:37 -0700571 *
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100572 * @image_objp: pointer to be set to the loaded image handle
573 * @loaded_image_infop: pointer to be set to the loaded image protocol
574 * @path: dummy file path used to construct the device path
575 * set in the loaded image protocol
576 * @load_options_path: name of a U-Boot environment variable. Its value is
577 * set as load options in the loaded image protocol.
578 * Return: status code
Simon Glassd9717ea2018-11-25 20:14:37 -0700579 */
580static efi_status_t bootefi_test_prepare
581 (struct efi_loaded_image_obj **image_objp,
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100582 struct efi_loaded_image **loaded_image_infop, const char *path,
583 const char *load_options_path)
Simon Glassd9717ea2018-11-25 20:14:37 -0700584{
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100585 efi_status_t ret;
586
Simon Glassd9717ea2018-11-25 20:14:37 -0700587 /* Construct a dummy device path */
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100588 bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, 0, 0);
Simon Glassd9717ea2018-11-25 20:14:37 -0700589 if (!bootefi_device_path)
590 return EFI_OUT_OF_RESOURCES;
Simon Glassd9717ea2018-11-25 20:14:37 -0700591
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100592 bootefi_image_path = efi_dp_from_file(NULL, 0, path);
593 if (!bootefi_image_path) {
594 ret = EFI_OUT_OF_RESOURCES;
595 goto failure;
596 }
597
598 ret = bootefi_run_prepare(load_options_path, bootefi_device_path,
599 bootefi_image_path, image_objp,
600 loaded_image_infop);
601 if (ret == EFI_SUCCESS)
602 return ret;
603
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100604failure:
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100605 efi_clear_bootdev();
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100606 return ret;
Simon Glassd9717ea2018-11-25 20:14:37 -0700607}
608
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900609/**
610 * bootefi_run_finish() - finish up after running an EFI test
611 *
612 * @loaded_image_info: Pointer to a struct which holds the loaded image info
613 * @image_obj: Pointer to a struct which holds the loaded image object
614 */
615static void bootefi_run_finish(struct efi_loaded_image_obj *image_obj,
616 struct efi_loaded_image *loaded_image_info)
617{
618 efi_restore_gd();
619 free(loaded_image_info->load_options);
620 efi_delete_handle(&image_obj->header);
621}
622
623/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200624 * do_efi_selftest() - execute EFI selftest
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900625 *
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900626 * Return: status code
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900627 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200628static int do_efi_selftest(void)
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900629{
630 struct efi_loaded_image_obj *image_obj;
631 struct efi_loaded_image *loaded_image_info;
632 efi_status_t ret;
633
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900634 ret = bootefi_test_prepare(&image_obj, &loaded_image_info,
635 "\\selftest", "efi_selftest");
636 if (ret != EFI_SUCCESS)
637 return CMD_RET_FAILURE;
638
639 /* Execute the test */
640 ret = EFI_CALL(efi_selftest(&image_obj->header, &systab));
641 bootefi_run_finish(image_obj, loaded_image_info);
642
643 return ret != EFI_SUCCESS;
644}
Simon Glassd9717ea2018-11-25 20:14:37 -0700645#endif /* CONFIG_CMD_BOOTEFI_SELFTEST */
646
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200647/**
648 * do_bootefi() - execute `bootefi` command
649 *
650 * @cmdtp: table entry describing command
651 * @flag: bitmap indicating how the command was invoked
652 * @argc: number of arguments
653 * @argv: command line arguments
654 * Return: status code
655 */
Simon Glass09140112020-05-10 11:40:03 -0600656static int do_bootefi(struct cmd_tbl *cmdtp, int flag, int argc,
657 char *const argv[])
Alexander Grafb9939332016-03-10 00:27:20 +0100658{
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200659 efi_status_t ret;
Heinrich Schuchardt8131c852022-05-19 08:00:56 +0200660 char *img_addr, *img_size, *str_copy, *pos;
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100661 void *fdt;
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200662
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900663 if (argc < 2)
664 return CMD_RET_USAGE;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900665
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200666 /* Initialize EFI drivers */
667 ret = efi_init_obj_list();
668 if (ret != EFI_SUCCESS) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200669 log_err("Error: Cannot initialize UEFI sub-system, r = %lu\n",
670 ret & ~EFI_ERROR_MASK);
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200671 return CMD_RET_FAILURE;
672 }
673
Heinrich Schuchardt8131c852022-05-19 08:00:56 +0200674 if (argc > 2) {
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100675 uintptr_t fdt_addr;
676
Simon Glass7e5f4602021-07-24 09:03:29 -0600677 fdt_addr = hextoul(argv[2], NULL);
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100678 fdt = map_sysmem(fdt_addr, 0);
679 } else {
680 fdt = EFI_FDT_USE_INTERNAL;
681 }
682 ret = efi_install_fdt(fdt);
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200683 if (ret == EFI_INVALID_PARAMETER)
684 return CMD_RET_USAGE;
685 else if (ret != EFI_SUCCESS)
686 return CMD_RET_FAILURE;
687
Heinrich Schuchardtff2f5322021-01-15 19:02:50 +0100688 if (IS_ENABLED(CONFIG_CMD_BOOTEFI_BOOTMGR)) {
689 if (!strcmp(argv[1], "bootmgr"))
690 return do_efibootmgr();
691 }
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900692#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
Heinrich Schuchardtff2f5322021-01-15 19:02:50 +0100693 if (!strcmp(argv[1], "selftest"))
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200694 return do_efi_selftest();
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900695#endif
Heinrich Schuchardt8131c852022-05-19 08:00:56 +0200696 str_copy = strdup(argv[1]);
697 if (!str_copy) {
698 log_err("Out of memory\n");
699 return CMD_RET_FAILURE;
700 }
701 pos = str_copy;
702 img_addr = strsep(&pos, ":");
703 img_size = strsep(&pos, ":");
704 ret = do_bootefi_image(img_addr, img_size);
705 free(str_copy);
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900706
Heinrich Schuchardt8131c852022-05-19 08:00:56 +0200707 return ret;
Alexander Grafb9939332016-03-10 00:27:20 +0100708}
709
710#ifdef CONFIG_SYS_LONGHELP
711static char bootefi_help_text[] =
Heinrich Schuchardt8131c852022-05-19 08:00:56 +0200712 "<image address>[:<image size>] [<fdt address>]\n"
713 " - boot EFI payload\n"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700714#ifdef CONFIG_CMD_BOOTEFI_HELLO
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200715 "bootefi hello\n"
716 " - boot a sample Hello World application stored within U-Boot\n"
717#endif
718#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100719 "bootefi selftest [fdt address]\n"
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200720 " - boot an EFI selftest application stored within U-Boot\n"
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200721 " Use environment variable efi_selftest to select a single test.\n"
722 " Use 'setenv efi_selftest list' to enumerate all tests.\n"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700723#endif
Heinrich Schuchardtff2f5322021-01-15 19:02:50 +0100724#ifdef CONFIG_CMD_BOOTEFI_BOOTMGR
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900725 "bootefi bootmgr [fdt address]\n"
Rob Clark9975fe92017-09-13 18:05:38 -0400726 " - load and boot EFI payload based on BootOrder/BootXXXX variables.\n"
727 "\n"
728 " If specified, the device tree located at <fdt address> gets\n"
Heinrich Schuchardtff2f5322021-01-15 19:02:50 +0100729 " exposed as EFI configuration table.\n"
730#endif
731 ;
Alexander Grafb9939332016-03-10 00:27:20 +0100732#endif
733
734U_BOOT_CMD(
Kyle Evans20589832022-04-10 16:05:55 -0500735 bootefi, 4, 0, do_bootefi,
Sergey Kubushyn92dfd922016-06-07 11:14:31 -0700736 "Boots an EFI payload from memory",
Alexander Grafb9939332016-03-10 00:27:20 +0100737 bootefi_help_text
738);