blob: cba81ffe75e4df3ab87a73f1b7367ec67483818e [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/**
38 * efi_clear_bootdev() - clear boot device
39 */
40static void efi_clear_bootdev(void)
41{
42 efi_free_pool(bootefi_device_path);
43 efi_free_pool(bootefi_image_path);
44 bootefi_device_path = NULL;
45 bootefi_image_path = NULL;
46 image_addr = NULL;
47 image_size = 0;
48}
49
50/**
51 * efi_set_bootdev() - set boot device
52 *
53 * This function is called when a file is loaded, e.g. via the 'load' command.
54 * We use the path to this file to inform the UEFI binary about the boot device.
55 *
56 * @dev: device, e.g. "MMC"
57 * @devnr: number of the device, e.g. "1:2"
58 * @path: path to file loaded
59 * @buffer: buffer with file loaded
60 * @buffer_size: size of file loaded
61 */
62void efi_set_bootdev(const char *dev, const char *devnr, const char *path,
63 void *buffer, size_t buffer_size)
64{
65 struct efi_device_path *device, *image;
66 efi_status_t ret;
67
68 /* Forget overwritten image */
69 if (buffer + buffer_size >= image_addr &&
70 image_addr + image_size >= buffer)
71 efi_clear_bootdev();
72
73 /* Remember only PE-COFF and FIT images */
74 if (efi_check_pe(buffer, buffer_size, NULL) != EFI_SUCCESS) {
75#ifdef CONFIG_FIT
Simon Glassc5819702021-02-15 17:08:09 -070076 if (fit_check_format(buffer, IMAGE_SIZE_INVAL))
Heinrich Schuchardt5f595182021-01-12 12:46:24 +010077 return;
78 /*
79 * FIT images of type EFI_OS are started via command bootm.
80 * We should not use their boot device with the bootefi command.
81 */
82 buffer = 0;
83 buffer_size = 0;
84#else
85 return;
86#endif
87 }
88
89 /* efi_set_bootdev() is typically called repeatedly, recover memory */
90 efi_clear_bootdev();
91
92 image_addr = buffer;
93 image_size = buffer_size;
94
95 ret = efi_dp_from_name(dev, devnr, path, &device, &image);
96 if (ret == EFI_SUCCESS) {
97 bootefi_device_path = device;
98 if (image) {
99 /* FIXME: image should not contain device */
100 struct efi_device_path *image_tmp = image;
101
102 efi_dp_split_file_path(image, &device, &image);
103 efi_free_pool(image_tmp);
104 }
105 bootefi_image_path = image;
106 } else {
107 efi_clear_bootdev();
108 }
109}
Alexander Grafb9939332016-03-10 00:27:20 +0100110
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200111/**
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200112 * efi_env_set_load_options() - set load options from environment variable
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200113 *
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100114 * @handle: the image handle
115 * @env_var: name of the environment variable
116 * @load_options: pointer to load options (output)
117 * Return: status code
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200118 */
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200119static efi_status_t efi_env_set_load_options(efi_handle_t handle,
120 const char *env_var,
121 u16 **load_options)
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200122{
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200123 const char *env = env_get(env_var);
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200124 size_t size;
Heinrich Schuchardt7086a712018-08-31 21:31:33 +0200125 u16 *pos;
AKASHI Takahirodefa7b82019-04-19 12:22:28 +0900126 efi_status_t ret;
127
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100128 *load_options = NULL;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200129 if (!env)
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200130 return EFI_SUCCESS;
131 size = sizeof(u16) * (utf8_utf16_strlen(env) + 1);
132 pos = calloc(size, 1);
133 if (!pos)
AKASHI Takahirodefa7b82019-04-19 12:22:28 +0900134 return EFI_OUT_OF_RESOURCES;
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100135 *load_options = pos;
Heinrich Schuchardt7086a712018-08-31 21:31:33 +0200136 utf8_utf16_strcpy(&pos, env);
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200137 ret = efi_set_load_options(handle, size, *load_options);
138 if (ret != EFI_SUCCESS) {
139 free(*load_options);
140 *load_options = NULL;
141 }
142 return ret;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200143}
144
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200145#if !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
146
Simon Glass9dff4902018-08-08 03:54:30 -0600147/**
148 * copy_fdt() - Copy the device tree to a new location available to EFI
149 *
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100150 * The FDT is copied to a suitable location within the EFI memory map.
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100151 * Additional 12 KiB are added to the space in case the device tree needs to be
Simon Glass9dff4902018-08-08 03:54:30 -0600152 * expanded later with fdt_open_into().
153 *
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100154 * @fdtp: On entry a pointer to the flattened device tree.
155 * On exit a pointer to the copy of the flattened device tree.
Heinrich Schuchardt4574d1b2018-11-12 18:55:22 +0100156 * FDT start
157 * Return: status code
Simon Glass9dff4902018-08-08 03:54:30 -0600158 */
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100159static efi_status_t copy_fdt(void **fdtp)
Alexander Graf0d9d5012016-04-11 16:55:26 +0200160{
Alexander Grafad0c1a32016-04-11 23:51:01 +0200161 unsigned long fdt_ram_start = -1L, fdt_pages;
Simon Glass9dff4902018-08-08 03:54:30 -0600162 efi_status_t ret = 0;
163 void *fdt, *new_fdt;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200164 u64 new_fdt_addr;
Simon Glass9dff4902018-08-08 03:54:30 -0600165 uint fdt_size;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200166 int i;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200167
Simon Glass9dff4902018-08-08 03:54:30 -0600168 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;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200171
Alexander Grafad0c1a32016-04-11 23:51:01 +0200172 if (!ram_size)
173 continue;
174
175 if (ram_start < fdt_ram_start)
176 fdt_ram_start = ram_start;
177 }
178
Simon Glassbc9a6382018-06-18 08:08:25 -0600179 /*
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100180 * Give us at least 12 KiB of breathing room in case the device tree
181 * needs to be expanded later.
Simon Glassbc9a6382018-06-18 08:08:25 -0600182 */
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100183 fdt = *fdtp;
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100184 fdt_pages = efi_size_in_pages(fdt_totalsize(fdt) + 0x3000);
185 fdt_size = fdt_pages << EFI_PAGE_SHIFT;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200186
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100187 /*
188 * Safe fdt location is at 127 MiB.
189 * On the sandbox convert from the sandbox address space.
190 */
191 new_fdt_addr = (uintptr_t)map_sysmem(fdt_ram_start + 0x7f00000 +
192 fdt_size, 0);
Simon Glass9dff4902018-08-08 03:54:30 -0600193 ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
Heinrich Schuchardt42a426e2020-05-06 20:32:31 +0200194 EFI_ACPI_RECLAIM_MEMORY, fdt_pages,
Simon Glass9dff4902018-08-08 03:54:30 -0600195 &new_fdt_addr);
196 if (ret != EFI_SUCCESS) {
Alexander Grafad0c1a32016-04-11 23:51:01 +0200197 /* If we can't put it there, put it somewhere */
xypron.glpk@gmx.dea44bffc2017-08-11 21:19:25 +0200198 new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size);
Simon Glass9dff4902018-08-08 03:54:30 -0600199 ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
Heinrich Schuchardt42a426e2020-05-06 20:32:31 +0200200 EFI_ACPI_RECLAIM_MEMORY, fdt_pages,
Simon Glass9dff4902018-08-08 03:54:30 -0600201 &new_fdt_addr);
202 if (ret != EFI_SUCCESS) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200203 log_err("ERROR: Failed to reserve space for FDT\n");
Simon Glass9dff4902018-08-08 03:54:30 -0600204 goto done;
Alexander Graf85a6e9b2017-07-03 13:32:35 +0200205 }
Alexander Grafad0c1a32016-04-11 23:51:01 +0200206 }
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100207 new_fdt = (void *)(uintptr_t)new_fdt_addr;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200208 memcpy(new_fdt, fdt, fdt_totalsize(fdt));
209 fdt_set_totalsize(new_fdt, fdt_size);
210
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100211 *fdtp = (void *)(uintptr_t)new_fdt_addr;
Simon Glass9dff4902018-08-08 03:54:30 -0600212done:
213 return ret;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200214}
215
Heinrich Schuchardt4cbb2932020-08-27 12:52:20 +0200216/**
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200217 * get_config_table() - get configuration table
218 *
219 * @guid: GUID of the configuration table
220 * Return: pointer to configuration table or NULL
221 */
222static void *get_config_table(const efi_guid_t *guid)
223{
224 size_t i;
225
226 for (i = 0; i < systab.nr_tables; i++) {
227 if (!guidcmp(guid, &systab.tables[i].guid))
228 return systab.tables[i].table;
229 }
230 return NULL;
231}
232
233#endif /* !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE) */
234
235/**
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100236 * efi_install_fdt() - install device tree
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200237 *
Heinrich Schuchardt7d4d5512020-02-07 22:10:49 +0100238 * If fdt is not EFI_FDT_USE_INTERNAL, the device tree located at that memory
239 * address will will be installed as configuration table, otherwise the device
240 * tree located at the address indicated by environment variable fdt_addr or as
241 * fallback fdtcontroladdr will be used.
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200242 *
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100243 * On architectures using ACPI tables device trees shall not be installed as
244 * configuration table.
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200245 *
Heinrich Schuchardt7d4d5512020-02-07 22:10:49 +0100246 * @fdt: address of device tree or EFI_FDT_USE_INTERNAL to use the
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100247 * the hardware device tree as indicated by environment variable
248 * fdt_addr or as fallback the internal device tree as indicated by
249 * the environment variable fdtcontroladdr
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900250 * Return: status code
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900251 */
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100252efi_status_t efi_install_fdt(void *fdt)
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900253{
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200254 /*
255 * The EBBR spec requires that we have either an FDT or an ACPI table
256 * but not both.
257 */
258#if CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100259 if (fdt) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200260 log_err("ERROR: can't have ACPI table and device tree.\n");
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200261 return EFI_LOAD_ERROR;
262 }
263#else
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900264 bootm_headers_t img = { 0 };
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900265 efi_status_t ret;
266
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100267 if (fdt == EFI_FDT_USE_INTERNAL) {
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100268 const char *fdt_opt;
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100269 uintptr_t fdt_addr;
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100270
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200271 /* Look for device tree that is already installed */
272 if (get_config_table(&efi_guid_fdt))
273 return EFI_SUCCESS;
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100274 /* Check if there is a hardware device tree */
275 fdt_opt = env_get("fdt_addr");
276 /* Use our own device tree as fallback */
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200277 if (!fdt_opt) {
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100278 fdt_opt = env_get("fdtcontroladdr");
279 if (!fdt_opt) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200280 log_err("ERROR: need device tree\n");
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100281 return EFI_NOT_FOUND;
282 }
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900283 }
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200284 fdt_addr = simple_strtoul(fdt_opt, NULL, 16);
285 if (!fdt_addr) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200286 log_err("ERROR: invalid $fdt_addr or $fdtcontroladdr\n");
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900287 return EFI_LOAD_ERROR;
288 }
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100289 fdt = map_sysmem(fdt_addr, 0);
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900290 }
291
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200292 /* Install device tree */
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200293 if (fdt_check_header(fdt)) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200294 log_err("ERROR: invalid device tree\n");
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200295 return EFI_LOAD_ERROR;
296 }
297
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200298 /* Prepare device tree for payload */
299 ret = copy_fdt(&fdt);
300 if (ret) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200301 log_err("ERROR: out of memory\n");
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200302 return EFI_OUT_OF_RESOURCES;
303 }
304
305 if (image_setup_libfdt(&img, fdt, 0, NULL)) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200306 log_err("ERROR: failed to process device tree\n");
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200307 return EFI_LOAD_ERROR;
308 }
309
Heinrich Schuchardtfef907b2020-03-14 10:59:34 +0100310 /* Create memory reservations as indicated by the device tree */
311 efi_carve_out_dt_rsv(fdt);
312
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200313 /* Install device tree as UEFI table */
314 ret = efi_install_configuration_table(&efi_guid_fdt, fdt);
315 if (ret != EFI_SUCCESS) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200316 log_err("ERROR: failed to install device tree\n");
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200317 return ret;
318 }
319#endif /* GENERATE_ACPI_TABLE */
320
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900321 return EFI_SUCCESS;
322}
323
Simon Glass5e2f0392018-11-25 20:14:39 -0700324/**
Heinrich Schuchardtc9828742018-09-23 17:21:51 +0200325 * do_bootefi_exec() - execute EFI binary
326 *
Heinrich Schuchardt72e1fca2020-08-15 23:10:22 +0200327 * The image indicated by @handle is started. When it returns the allocated
328 * memory for the @load_options is freed.
329 *
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900330 * @handle: handle of loaded image
Heinrich Schuchardt72e1fca2020-08-15 23:10:22 +0200331 * @load_options: load options
Heinrich Schuchardtc9828742018-09-23 17:21:51 +0200332 * Return: status code
333 *
334 * Load the EFI binary into a newly assigned memory unwinding the relocation
335 * information, install the loaded image protocol, and call the binary.
Alexander Grafb9939332016-03-10 00:27:20 +0100336 */
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200337static efi_status_t do_bootefi_exec(efi_handle_t handle, void *load_options)
Alexander Grafb9939332016-03-10 00:27:20 +0100338{
Heinrich Schuchardt45204b12018-03-03 15:29:01 +0100339 efi_status_t ret;
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200340 efi_uintn_t exit_data_size = 0;
341 u16 *exit_data = NULL;
Rob Clarkbf192732017-10-10 08:23:06 -0400342
Heinrich Schuchardt82d01f02021-01-24 14:34:12 +0000343 /* On ARM switch from EL3 or secure mode to EL2 or non-secure mode */
344 switch_to_non_secure_mode();
345
Alexander Grafb9939332016-03-10 00:27:20 +0100346 /* Call our payload! */
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200347 ret = EFI_CALL(efi_start_image(handle, &exit_data_size, &exit_data));
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200348 if (ret != EFI_SUCCESS) {
349 log_err("## Application failed, r = %lu\n",
350 ret & ~EFI_ERROR_MASK);
351 if (exit_data) {
352 log_err("## %ls\n", exit_data);
353 efi_free_pool(exit_data);
354 }
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200355 }
Rob Clark95c55532017-09-13 18:05:33 -0400356
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900357 efi_restore_gd();
Simon Glass5e2f0392018-11-25 20:14:39 -0700358
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100359 free(load_options);
Rob Clark95c55532017-09-13 18:05:33 -0400360
Ilias Apalodimas53f6a5a2021-03-17 21:55:00 +0200361 if (IS_ENABLED(CONFIG_EFI_LOAD_FILE2_INITRD))
362 efi_initrd_deregister();
363
Rob Clark95c55532017-09-13 18:05:33 -0400364 return ret;
Alexander Grafb9939332016-03-10 00:27:20 +0100365}
366
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900367/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200368 * do_efibootmgr() - execute EFI boot manager
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900369 *
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900370 * Return: status code
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900371 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200372static int do_efibootmgr(void)
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900373{
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900374 efi_handle_t handle;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900375 efi_status_t ret;
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200376 void *load_options;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900377
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200378 ret = efi_bootmgr_load(&handle, &load_options);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900379 if (ret != EFI_SUCCESS) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200380 log_notice("EFI boot manager: Cannot load any image\n");
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900381 return CMD_RET_FAILURE;
382 }
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900383
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200384 ret = do_bootefi_exec(handle, load_options);
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900385
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900386 if (ret != EFI_SUCCESS)
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900387 return CMD_RET_FAILURE;
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900388
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900389 return CMD_RET_SUCCESS;
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900390}
391
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200392/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200393 * do_bootefi_image() - execute EFI binary
394 *
395 * Set up memory image for the binary to be loaded, prepare device path, and
396 * then call do_bootefi_exec() to execute it.
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900397 *
398 * @image_opt: string of image start address
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900399 * Return: status code
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900400 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200401static int do_bootefi_image(const char *image_opt)
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900402{
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900403 void *image_buf;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900404 unsigned long addr, size;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900405 efi_status_t ret;
406
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900407#ifdef CONFIG_CMD_BOOTEFI_HELLO
408 if (!strcmp(image_opt, "hello")) {
Heinrich Schuchardtbb33c792021-01-12 17:44:08 +0100409 image_buf = __efi_helloworld_begin;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900410 size = __efi_helloworld_end - __efi_helloworld_begin;
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100411 efi_clear_bootdev();
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900412 } else
413#endif
414 {
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100415 addr = strtoul(image_opt, NULL, 16);
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900416 /* Check that a numeric value was passed */
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100417 if (!addr)
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900418 return CMD_RET_USAGE;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900419
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100420 image_buf = map_sysmem(addr, 0);
421
422 if (image_buf != image_addr) {
423 log_err("No UEFI binary known at %s\n", image_opt);
424 return CMD_RET_FAILURE;
425 }
426 size = image_size;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900427 }
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100428 ret = efi_run_image(image_buf, size);
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900429
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100430 if (ret != EFI_SUCCESS)
431 return CMD_RET_FAILURE;
432
433 return CMD_RET_SUCCESS;
434}
435
436/**
437 * efi_run_image() - run loaded UEFI image
438 *
439 * @source_buffer: memory address of the UEFI image
440 * @source_size: size of the UEFI image
441 * Return: status code
442 */
443efi_status_t efi_run_image(void *source_buffer, efi_uintn_t source_size)
444{
445 efi_handle_t mem_handle = NULL, handle;
446 struct efi_device_path *file_path = NULL;
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000447 struct efi_device_path *msg_path;
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100448 efi_status_t ret;
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000449 u16 *load_options;
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100450
451 if (!bootefi_device_path || !bootefi_image_path) {
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900452 /*
453 * Special case for efi payload not loaded from disk,
454 * such as 'bootefi hello' or for example payload
455 * loaded directly into memory via JTAG, etc:
456 */
457 file_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE,
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100458 (uintptr_t)source_buffer,
459 source_size);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900460 /*
461 * Make sure that device for device_path exist
462 * in load_image(). Otherwise, shell and grub will fail.
463 */
464 ret = efi_create_handle(&mem_handle);
465 if (ret != EFI_SUCCESS)
466 goto out;
467
468 ret = efi_add_protocol(mem_handle, &efi_guid_device_path,
469 file_path);
470 if (ret != EFI_SUCCESS)
471 goto out;
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000472 msg_path = file_path;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900473 } else {
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100474 file_path = efi_dp_append(bootefi_device_path,
475 bootefi_image_path);
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000476 msg_path = bootefi_image_path;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900477 }
478
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000479 log_info("Booting %pD\n", msg_path);
480
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100481 ret = EFI_CALL(efi_load_image(false, efi_root, file_path, source_buffer,
482 source_size, &handle));
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000483 if (ret != EFI_SUCCESS) {
484 log_err("Loading image failed\n");
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900485 goto out;
Heinrich Schuchardtc2f01032020-08-25 17:54:05 +0000486 }
Heinrich Schuchardt0ad64002020-08-07 17:49:39 +0200487
488 /* Transfer environment variable as load options */
489 ret = efi_env_set_load_options(handle, "bootargs", &load_options);
490 if (ret != EFI_SUCCESS)
491 goto out;
492
493 ret = do_bootefi_exec(handle, load_options);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900494
495out:
Heinrich Schuchardt4fe050e2020-04-20 12:44:56 +0200496 efi_delete_handle(mem_handle);
497 efi_free_pool(file_path);
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100498 return ret;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900499}
500
Simon Glassd9717ea2018-11-25 20:14:37 -0700501#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900502static efi_status_t bootefi_run_prepare(const char *load_options_path,
503 struct efi_device_path *device_path,
504 struct efi_device_path *image_path,
505 struct efi_loaded_image_obj **image_objp,
506 struct efi_loaded_image **loaded_image_infop)
507{
508 efi_status_t ret;
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100509 u16 *load_options;
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900510
511 ret = efi_setup_loaded_image(device_path, image_path, image_objp,
512 loaded_image_infop);
513 if (ret != EFI_SUCCESS)
514 return ret;
515
516 /* Transfer environment variable as load options */
Heinrich Schuchardt1064d042020-08-07 17:47:13 +0200517 return efi_env_set_load_options((efi_handle_t)*image_objp,
518 load_options_path,
519 &load_options);
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900520}
521
Simon Glassd9717ea2018-11-25 20:14:37 -0700522/**
523 * bootefi_test_prepare() - prepare to run an EFI test
524 *
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100525 * Prepare to run a test as if it were provided by a loaded image.
Simon Glassd9717ea2018-11-25 20:14:37 -0700526 *
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100527 * @image_objp: pointer to be set to the loaded image handle
528 * @loaded_image_infop: pointer to be set to the loaded image protocol
529 * @path: dummy file path used to construct the device path
530 * set in the loaded image protocol
531 * @load_options_path: name of a U-Boot environment variable. Its value is
532 * set as load options in the loaded image protocol.
533 * Return: status code
Simon Glassd9717ea2018-11-25 20:14:37 -0700534 */
535static efi_status_t bootefi_test_prepare
536 (struct efi_loaded_image_obj **image_objp,
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100537 struct efi_loaded_image **loaded_image_infop, const char *path,
538 const char *load_options_path)
Simon Glassd9717ea2018-11-25 20:14:37 -0700539{
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100540 efi_status_t ret;
541
Simon Glassd9717ea2018-11-25 20:14:37 -0700542 /* Construct a dummy device path */
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100543 bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, 0, 0);
Simon Glassd9717ea2018-11-25 20:14:37 -0700544 if (!bootefi_device_path)
545 return EFI_OUT_OF_RESOURCES;
Simon Glassd9717ea2018-11-25 20:14:37 -0700546
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100547 bootefi_image_path = efi_dp_from_file(NULL, 0, path);
548 if (!bootefi_image_path) {
549 ret = EFI_OUT_OF_RESOURCES;
550 goto failure;
551 }
552
553 ret = bootefi_run_prepare(load_options_path, bootefi_device_path,
554 bootefi_image_path, image_objp,
555 loaded_image_infop);
556 if (ret == EFI_SUCCESS)
557 return ret;
558
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100559failure:
Heinrich Schuchardt5f595182021-01-12 12:46:24 +0100560 efi_clear_bootdev();
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100561 return ret;
Simon Glassd9717ea2018-11-25 20:14:37 -0700562}
563
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900564/**
565 * bootefi_run_finish() - finish up after running an EFI test
566 *
567 * @loaded_image_info: Pointer to a struct which holds the loaded image info
568 * @image_obj: Pointer to a struct which holds the loaded image object
569 */
570static void bootefi_run_finish(struct efi_loaded_image_obj *image_obj,
571 struct efi_loaded_image *loaded_image_info)
572{
573 efi_restore_gd();
574 free(loaded_image_info->load_options);
575 efi_delete_handle(&image_obj->header);
576}
577
578/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200579 * do_efi_selftest() - execute EFI selftest
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900580 *
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900581 * Return: status code
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900582 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200583static int do_efi_selftest(void)
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900584{
585 struct efi_loaded_image_obj *image_obj;
586 struct efi_loaded_image *loaded_image_info;
587 efi_status_t ret;
588
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900589 ret = bootefi_test_prepare(&image_obj, &loaded_image_info,
590 "\\selftest", "efi_selftest");
591 if (ret != EFI_SUCCESS)
592 return CMD_RET_FAILURE;
593
594 /* Execute the test */
595 ret = EFI_CALL(efi_selftest(&image_obj->header, &systab));
596 bootefi_run_finish(image_obj, loaded_image_info);
597
598 return ret != EFI_SUCCESS;
599}
Simon Glassd9717ea2018-11-25 20:14:37 -0700600#endif /* CONFIG_CMD_BOOTEFI_SELFTEST */
601
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200602/**
603 * do_bootefi() - execute `bootefi` command
604 *
605 * @cmdtp: table entry describing command
606 * @flag: bitmap indicating how the command was invoked
607 * @argc: number of arguments
608 * @argv: command line arguments
609 * Return: status code
610 */
Simon Glass09140112020-05-10 11:40:03 -0600611static int do_bootefi(struct cmd_tbl *cmdtp, int flag, int argc,
612 char *const argv[])
Alexander Grafb9939332016-03-10 00:27:20 +0100613{
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200614 efi_status_t ret;
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100615 void *fdt;
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200616
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900617 if (argc < 2)
618 return CMD_RET_USAGE;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900619
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200620 /* Initialize EFI drivers */
621 ret = efi_init_obj_list();
622 if (ret != EFI_SUCCESS) {
Heinrich Schuchardtc0018372020-07-17 20:21:00 +0200623 log_err("Error: Cannot initialize UEFI sub-system, r = %lu\n",
624 ret & ~EFI_ERROR_MASK);
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200625 return CMD_RET_FAILURE;
626 }
627
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100628 if (argc > 2) {
629 uintptr_t fdt_addr;
630
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100631 fdt_addr = simple_strtoul(argv[2], NULL, 16);
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100632 fdt = map_sysmem(fdt_addr, 0);
633 } else {
634 fdt = EFI_FDT_USE_INTERNAL;
635 }
636 ret = efi_install_fdt(fdt);
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200637 if (ret == EFI_INVALID_PARAMETER)
638 return CMD_RET_USAGE;
639 else if (ret != EFI_SUCCESS)
640 return CMD_RET_FAILURE;
641
Heinrich Schuchardtff2f5322021-01-15 19:02:50 +0100642 if (IS_ENABLED(CONFIG_CMD_BOOTEFI_BOOTMGR)) {
643 if (!strcmp(argv[1], "bootmgr"))
644 return do_efibootmgr();
645 }
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900646#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
Heinrich Schuchardtff2f5322021-01-15 19:02:50 +0100647 if (!strcmp(argv[1], "selftest"))
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200648 return do_efi_selftest();
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900649#endif
650
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200651 return do_bootefi_image(argv[1]);
Alexander Grafb9939332016-03-10 00:27:20 +0100652}
653
654#ifdef CONFIG_SYS_LONGHELP
655static char bootefi_help_text[] =
Alexander Graf1c398092016-04-14 16:07:53 +0200656 "<image address> [fdt address]\n"
657 " - boot EFI payload stored at address <image address>.\n"
658 " If specified, the device tree located at <fdt address> gets\n"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700659 " exposed as EFI configuration table.\n"
660#ifdef CONFIG_CMD_BOOTEFI_HELLO
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200661 "bootefi hello\n"
662 " - boot a sample Hello World application stored within U-Boot\n"
663#endif
664#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100665 "bootefi selftest [fdt address]\n"
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200666 " - boot an EFI selftest application stored within U-Boot\n"
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200667 " Use environment variable efi_selftest to select a single test.\n"
668 " Use 'setenv efi_selftest list' to enumerate all tests.\n"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700669#endif
Heinrich Schuchardtff2f5322021-01-15 19:02:50 +0100670#ifdef CONFIG_CMD_BOOTEFI_BOOTMGR
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900671 "bootefi bootmgr [fdt address]\n"
Rob Clark9975fe92017-09-13 18:05:38 -0400672 " - load and boot EFI payload based on BootOrder/BootXXXX variables.\n"
673 "\n"
674 " If specified, the device tree located at <fdt address> gets\n"
Heinrich Schuchardtff2f5322021-01-15 19:02:50 +0100675 " exposed as EFI configuration table.\n"
676#endif
677 ;
Alexander Grafb9939332016-03-10 00:27:20 +0100678#endif
679
680U_BOOT_CMD(
Alexander Graf1c398092016-04-14 16:07:53 +0200681 bootefi, 3, 0, do_bootefi,
Sergey Kubushyn92dfd922016-06-07 11:14:31 -0700682 "Boots an EFI payload from memory",
Alexander Grafb9939332016-03-10 00:27:20 +0100683 bootefi_help_text
684);