blob: aaed575505968b8f65b4ae89adf9e39b2e251b8e [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>
Simon Glass7b51b572019-08-01 09:46:52 -060014#include <env.h>
Alexander Grafb9939332016-03-10 00:27:20 +010015#include <errno.h>
Simon Glass336d4612020-02-03 07:36:16 -070016#include <malloc.h>
Masahiro Yamadab08c8c42018-03-05 01:20:11 +090017#include <linux/libfdt.h>
18#include <linux/libfdt_env.h>
Alexander Graf354264b2018-06-18 17:22:58 +020019#include <mapmem.h>
Alexander Grafad0c1a32016-04-11 23:51:01 +020020#include <memalign.h>
Simon Glasse2754582016-09-25 15:27:32 -060021#include <asm-generic/sections.h>
22#include <linux/linkage.h>
Alexander Graf0d9d5012016-04-11 16:55:26 +020023
24DECLARE_GLOBAL_DATA_PTR;
Alexander Grafb9939332016-03-10 00:27:20 +010025
Rob Clark95c55532017-09-13 18:05:33 -040026static struct efi_device_path *bootefi_image_path;
27static struct efi_device_path *bootefi_device_path;
Alexander Grafb9939332016-03-10 00:27:20 +010028
Heinrich Schuchardt810371a2019-07-14 13:00:44 +020029/**
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020030 * Set the load options of an image from an environment variable.
31 *
Heinrich Schuchardta3850e42020-01-03 22:53:42 +010032 * @handle: the image handle
33 * @env_var: name of the environment variable
34 * @load_options: pointer to load options (output)
35 * Return: status code
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020036 */
Heinrich Schuchardta3850e42020-01-03 22:53:42 +010037static efi_status_t set_load_options(efi_handle_t handle, const char *env_var,
38 u16 **load_options)
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020039{
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090040 struct efi_loaded_image *loaded_image_info;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020041 size_t size;
42 const char *env = env_get(env_var);
Heinrich Schuchardt7086a712018-08-31 21:31:33 +020043 u16 *pos;
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090044 efi_status_t ret;
45
Heinrich Schuchardta3850e42020-01-03 22:53:42 +010046 *load_options = NULL;
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090047 ret = EFI_CALL(systab.boottime->open_protocol(
48 handle,
49 &efi_guid_loaded_image,
50 (void **)&loaded_image_info,
51 efi_root, NULL,
52 EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL));
53 if (ret != EFI_SUCCESS)
54 return EFI_INVALID_PARAMETER;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020055
56 loaded_image_info->load_options = NULL;
57 loaded_image_info->load_options_size = 0;
58 if (!env)
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090059 goto out;
60
Heinrich Schuchardt7086a712018-08-31 21:31:33 +020061 size = utf8_utf16_strlen(env) + 1;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020062 loaded_image_info->load_options = calloc(size, sizeof(u16));
63 if (!loaded_image_info->load_options) {
64 printf("ERROR: Out of memory\n");
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090065 EFI_CALL(systab.boottime->close_protocol(handle,
66 &efi_guid_loaded_image,
67 efi_root, NULL));
68 return EFI_OUT_OF_RESOURCES;
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020069 }
Heinrich Schuchardt7086a712018-08-31 21:31:33 +020070 pos = loaded_image_info->load_options;
Heinrich Schuchardta3850e42020-01-03 22:53:42 +010071 *load_options = pos;
Heinrich Schuchardt7086a712018-08-31 21:31:33 +020072 utf8_utf16_strcpy(&pos, env);
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020073 loaded_image_info->load_options_size = size * 2;
AKASHI Takahirodefa7b82019-04-19 12:22:28 +090074
75out:
76 return EFI_CALL(systab.boottime->close_protocol(handle,
77 &efi_guid_loaded_image,
78 efi_root, NULL));
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020079}
80
Heinrich Schuchardt61824952019-04-20 13:33:55 +020081#if !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
82
Simon Glass9dff4902018-08-08 03:54:30 -060083/**
84 * copy_fdt() - Copy the device tree to a new location available to EFI
85 *
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +010086 * The FDT is copied to a suitable location within the EFI memory map.
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +010087 * Additional 12 KiB are added to the space in case the device tree needs to be
Simon Glass9dff4902018-08-08 03:54:30 -060088 * expanded later with fdt_open_into().
89 *
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +010090 * @fdtp: On entry a pointer to the flattened device tree.
91 * On exit a pointer to the copy of the flattened device tree.
Heinrich Schuchardt4574d1b2018-11-12 18:55:22 +010092 * FDT start
93 * Return: status code
Simon Glass9dff4902018-08-08 03:54:30 -060094 */
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +010095static efi_status_t copy_fdt(void **fdtp)
Alexander Graf0d9d5012016-04-11 16:55:26 +020096{
Alexander Grafad0c1a32016-04-11 23:51:01 +020097 unsigned long fdt_ram_start = -1L, fdt_pages;
Simon Glass9dff4902018-08-08 03:54:30 -060098 efi_status_t ret = 0;
99 void *fdt, *new_fdt;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200100 u64 new_fdt_addr;
Simon Glass9dff4902018-08-08 03:54:30 -0600101 uint fdt_size;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200102 int i;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200103
Simon Glass9dff4902018-08-08 03:54:30 -0600104 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
105 u64 ram_start = gd->bd->bi_dram[i].start;
106 u64 ram_size = gd->bd->bi_dram[i].size;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200107
Alexander Grafad0c1a32016-04-11 23:51:01 +0200108 if (!ram_size)
109 continue;
110
111 if (ram_start < fdt_ram_start)
112 fdt_ram_start = ram_start;
113 }
114
Simon Glassbc9a6382018-06-18 08:08:25 -0600115 /*
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100116 * Give us at least 12 KiB of breathing room in case the device tree
117 * needs to be expanded later.
Simon Glassbc9a6382018-06-18 08:08:25 -0600118 */
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100119 fdt = *fdtp;
Heinrich Schuchardtc3772ca2018-11-18 17:58:49 +0100120 fdt_pages = efi_size_in_pages(fdt_totalsize(fdt) + 0x3000);
121 fdt_size = fdt_pages << EFI_PAGE_SHIFT;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200122
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100123 /*
124 * Safe fdt location is at 127 MiB.
125 * On the sandbox convert from the sandbox address space.
126 */
127 new_fdt_addr = (uintptr_t)map_sysmem(fdt_ram_start + 0x7f00000 +
128 fdt_size, 0);
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 Grafad0c1a32016-04-11 23:51:01 +0200133 /* If we can't put it there, put it somewhere */
xypron.glpk@gmx.dea44bffc2017-08-11 21:19:25 +0200134 new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size);
Simon Glass9dff4902018-08-08 03:54:30 -0600135 ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
Ilias Apalodimas29361ec2019-04-12 21:26:28 +0300136 EFI_BOOT_SERVICES_DATA, fdt_pages,
Simon Glass9dff4902018-08-08 03:54:30 -0600137 &new_fdt_addr);
138 if (ret != EFI_SUCCESS) {
Alexander Graf85a6e9b2017-07-03 13:32:35 +0200139 printf("ERROR: Failed to reserve space for FDT\n");
Simon Glass9dff4902018-08-08 03:54:30 -0600140 goto done;
Alexander Graf85a6e9b2017-07-03 13:32:35 +0200141 }
Alexander Grafad0c1a32016-04-11 23:51:01 +0200142 }
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100143 new_fdt = (void *)(uintptr_t)new_fdt_addr;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200144 memcpy(new_fdt, fdt, fdt_totalsize(fdt));
145 fdt_set_totalsize(new_fdt, fdt_size);
146
Heinrich Schuchardt16b615d2018-11-18 17:58:52 +0100147 *fdtp = (void *)(uintptr_t)new_fdt_addr;
Simon Glass9dff4902018-08-08 03:54:30 -0600148done:
149 return ret;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200150}
151
Atish Patra7be64b82020-03-13 17:11:30 -0700152static void efi_reserve_memory(u64 addr, u64 size)
153{
154 u64 pages;
155
156 /* Convert from sandbox address space. */
157 addr = (uintptr_t)map_sysmem(addr, 0);
158 pages = efi_size_in_pages(size + (addr & EFI_PAGE_MASK));
159 addr &= ~EFI_PAGE_MASK;
160 if (efi_add_memory_map(addr, pages, EFI_RESERVED_MEMORY_TYPE,
161 false) != EFI_SUCCESS)
162 printf("Reserved memory mapping failed addr %llx size %llx\n",
163 addr, size);
164}
165
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200166/**
Simon Glass416e07e2018-06-18 08:08:28 -0600167 * efi_carve_out_dt_rsv() - Carve out DT reserved memory ranges
168 *
169 * The mem_rsv entries of the FDT are added to the memory map. Any failures are
170 * ignored because this is not critical and we would rather continue to try to
171 * boot.
172 *
173 * @fdt: Pointer to device tree
174 */
175static void efi_carve_out_dt_rsv(void *fdt)
Alexander Graf806d2fa2018-04-06 09:40:51 +0200176{
177 int nr_rsv, i;
Atish Patra7be64b82020-03-13 17:11:30 -0700178 u64 addr, size;
179 int nodeoffset, subnode;
Alexander Graf806d2fa2018-04-06 09:40:51 +0200180
181 nr_rsv = fdt_num_mem_rsv(fdt);
182
183 /* Look for an existing entry and add it to the efi mem map. */
184 for (i = 0; i < nr_rsv; i++) {
185 if (fdt_get_mem_rsv(fdt, i, &addr, &size) != 0)
186 continue;
Atish Patra7be64b82020-03-13 17:11:30 -0700187 efi_reserve_memory(addr, size);
188 }
Alexander Graf806d2fa2018-04-06 09:40:51 +0200189
Atish Patra7be64b82020-03-13 17:11:30 -0700190 /* process reserved-memory */
191 nodeoffset = fdt_subnode_offset(fdt, 0, "reserved-memory");
192 if (nodeoffset >= 0) {
193 subnode = fdt_first_subnode(fdt, nodeoffset);
194 while (subnode >= 0) {
195 /* check if this subnode has a reg property */
196 addr = fdtdec_get_addr_size(fdt, subnode, "reg",
197 (fdt_size_t *)&size);
198 /*
199 * The /reserved-memory node may have children with
200 * a size instead of a reg property.
201 */
Heinrich Schuchardt4ef2b0d2020-03-24 07:37:52 +0100202 if (addr != FDT_ADDR_T_NONE &&
203 fdtdec_get_is_enabled(fdt, subnode))
Atish Patra7be64b82020-03-13 17:11:30 -0700204 efi_reserve_memory(addr, size);
205 subnode = fdt_next_subnode(fdt, subnode);
206 }
Alexander Graf806d2fa2018-04-06 09:40:51 +0200207 }
Alexander Graf806d2fa2018-04-06 09:40:51 +0200208}
209
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900210/**
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200211 * get_config_table() - get configuration table
212 *
213 * @guid: GUID of the configuration table
214 * Return: pointer to configuration table or NULL
215 */
216static void *get_config_table(const efi_guid_t *guid)
217{
218 size_t i;
219
220 for (i = 0; i < systab.nr_tables; i++) {
221 if (!guidcmp(guid, &systab.tables[i].guid))
222 return systab.tables[i].table;
223 }
224 return NULL;
225}
226
227#endif /* !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE) */
228
229/**
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100230 * efi_install_fdt() - install device tree
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200231 *
Heinrich Schuchardt7d4d5512020-02-07 22:10:49 +0100232 * If fdt is not EFI_FDT_USE_INTERNAL, the device tree located at that memory
233 * address will will be installed as configuration table, otherwise the device
234 * tree located at the address indicated by environment variable fdt_addr or as
235 * fallback fdtcontroladdr will be used.
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200236 *
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100237 * On architectures using ACPI tables device trees shall not be installed as
238 * configuration table.
Heinrich Schuchardte2d82f82019-05-12 20:16:25 +0200239 *
Heinrich Schuchardt7d4d5512020-02-07 22:10:49 +0100240 * @fdt: address of device tree or EFI_FDT_USE_INTERNAL to use the
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100241 * the hardware device tree as indicated by environment variable
242 * fdt_addr or as fallback the internal device tree as indicated by
243 * the environment variable fdtcontroladdr
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900244 * Return: status code
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900245 */
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100246efi_status_t efi_install_fdt(void *fdt)
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900247{
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200248 /*
249 * The EBBR spec requires that we have either an FDT or an ACPI table
250 * but not both.
251 */
252#if CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100253 if (fdt) {
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200254 printf("ERROR: can't have ACPI table and device tree.\n");
255 return EFI_LOAD_ERROR;
256 }
257#else
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900258 bootm_headers_t img = { 0 };
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900259 efi_status_t ret;
260
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100261 if (fdt == EFI_FDT_USE_INTERNAL) {
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100262 const char *fdt_opt;
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100263 uintptr_t fdt_addr;
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100264
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200265 /* Look for device tree that is already installed */
266 if (get_config_table(&efi_guid_fdt))
267 return EFI_SUCCESS;
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100268 /* Check if there is a hardware device tree */
269 fdt_opt = env_get("fdt_addr");
270 /* Use our own device tree as fallback */
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200271 if (!fdt_opt) {
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100272 fdt_opt = env_get("fdtcontroladdr");
273 if (!fdt_opt) {
274 printf("ERROR: need device tree\n");
275 return EFI_NOT_FOUND;
276 }
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900277 }
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200278 fdt_addr = simple_strtoul(fdt_opt, NULL, 16);
279 if (!fdt_addr) {
Heinrich Schuchardt753aa182019-12-04 12:31:12 +0100280 printf("ERROR: invalid $fdt_addr or $fdtcontroladdr\n");
AKASHI Takahiro3ffc52f2019-04-19 12:22:30 +0900281 return EFI_LOAD_ERROR;
282 }
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100283 fdt = map_sysmem(fdt_addr, 0);
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900284 }
285
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200286 /* Install device tree */
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200287 if (fdt_check_header(fdt)) {
288 printf("ERROR: invalid device tree\n");
289 return EFI_LOAD_ERROR;
290 }
291
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200292 /* Prepare device tree for payload */
293 ret = copy_fdt(&fdt);
294 if (ret) {
295 printf("ERROR: out of memory\n");
296 return EFI_OUT_OF_RESOURCES;
297 }
298
299 if (image_setup_libfdt(&img, fdt, 0, NULL)) {
300 printf("ERROR: failed to process device tree\n");
301 return EFI_LOAD_ERROR;
302 }
303
Heinrich Schuchardtfef907b2020-03-14 10:59:34 +0100304 /* Create memory reservations as indicated by the device tree */
305 efi_carve_out_dt_rsv(fdt);
306
Heinrich Schuchardt61824952019-04-20 13:33:55 +0200307 /* Install device tree as UEFI table */
308 ret = efi_install_configuration_table(&efi_guid_fdt, fdt);
309 if (ret != EFI_SUCCESS) {
310 printf("ERROR: failed to install device tree\n");
311 return ret;
312 }
313#endif /* GENERATE_ACPI_TABLE */
314
AKASHI Takahiroe878e6a2019-04-19 12:22:29 +0900315 return EFI_SUCCESS;
316}
317
Simon Glass5e2f0392018-11-25 20:14:39 -0700318/**
Heinrich Schuchardtc9828742018-09-23 17:21:51 +0200319 * do_bootefi_exec() - execute EFI binary
320 *
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900321 * @handle: handle of loaded image
Heinrich Schuchardtc9828742018-09-23 17:21:51 +0200322 * Return: status code
323 *
324 * Load the EFI binary into a newly assigned memory unwinding the relocation
325 * information, install the loaded image protocol, and call the binary.
Alexander Grafb9939332016-03-10 00:27:20 +0100326 */
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900327static efi_status_t do_bootefi_exec(efi_handle_t handle)
Alexander Grafb9939332016-03-10 00:27:20 +0100328{
Heinrich Schuchardt45204b12018-03-03 15:29:01 +0100329 efi_status_t ret;
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200330 efi_uintn_t exit_data_size = 0;
331 u16 *exit_data = NULL;
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100332 u16 *load_options;
Rob Clark95c55532017-09-13 18:05:33 -0400333
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900334 /* Transfer environment variable as load options */
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100335 ret = set_load_options(handle, "bootargs", &load_options);
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900336 if (ret != EFI_SUCCESS)
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900337 return ret;
Rob Clarkbf192732017-10-10 08:23:06 -0400338
Alexander Grafb9939332016-03-10 00:27:20 +0100339 /* Call our payload! */
Heinrich Schuchardt556d8dc2019-04-30 17:57:30 +0200340 ret = EFI_CALL(efi_start_image(handle, &exit_data_size, &exit_data));
341 printf("## Application terminated, r = %lu\n", ret & ~EFI_ERROR_MASK);
342 if (ret && exit_data) {
343 printf("## %ls\n", exit_data);
344 efi_free_pool(exit_data);
345 }
Rob Clark95c55532017-09-13 18:05:33 -0400346
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900347 efi_restore_gd();
Simon Glass5e2f0392018-11-25 20:14:39 -0700348
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100349 free(load_options);
Rob Clark95c55532017-09-13 18:05:33 -0400350
351 return ret;
Alexander Grafb9939332016-03-10 00:27:20 +0100352}
353
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900354/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200355 * do_efibootmgr() - execute EFI boot manager
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900356 *
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900357 * Return: status code
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900358 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200359static int do_efibootmgr(void)
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900360{
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900361 efi_handle_t handle;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900362 efi_status_t ret;
363
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900364 ret = efi_bootmgr_load(&handle);
365 if (ret != EFI_SUCCESS) {
366 printf("EFI boot manager: Cannot load any image\n");
367 return CMD_RET_FAILURE;
368 }
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900369
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900370 ret = do_bootefi_exec(handle);
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900371
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900372 if (ret != EFI_SUCCESS)
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900373 return CMD_RET_FAILURE;
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900374
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900375 return CMD_RET_SUCCESS;
AKASHI Takahirocc999d52019-04-19 12:22:32 +0900376}
377
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200378/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200379 * do_bootefi_image() - execute EFI binary
380 *
381 * Set up memory image for the binary to be loaded, prepare device path, and
382 * then call do_bootefi_exec() to execute it.
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900383 *
384 * @image_opt: string of image start address
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900385 * Return: status code
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900386 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200387static int do_bootefi_image(const char *image_opt)
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900388{
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900389 void *image_buf;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900390 unsigned long addr, size;
391 const char *size_str;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900392 efi_status_t ret;
393
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900394#ifdef CONFIG_CMD_BOOTEFI_HELLO
395 if (!strcmp(image_opt, "hello")) {
396 char *saddr;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900397
398 saddr = env_get("loadaddr");
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900399 size = __efi_helloworld_end - __efi_helloworld_begin;
400
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900401 if (saddr)
402 addr = simple_strtoul(saddr, NULL, 16);
403 else
404 addr = CONFIG_SYS_LOAD_ADDR;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900405
406 image_buf = map_sysmem(addr, size);
407 memcpy(image_buf, __efi_helloworld_begin, size);
408
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100409 efi_free_pool(bootefi_device_path);
410 efi_free_pool(bootefi_image_path);
411 bootefi_device_path = NULL;
412 bootefi_image_path = NULL;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900413 } else
414#endif
415 {
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900416 size_str = env_get("filesize");
417 if (size_str)
418 size = simple_strtoul(size_str, NULL, 16);
419 else
420 size = 0;
421
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900422 addr = simple_strtoul(image_opt, NULL, 16);
423 /* Check that a numeric value was passed */
424 if (!addr && *image_opt != '0')
425 return CMD_RET_USAGE;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900426
427 image_buf = map_sysmem(addr, size);
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900428 }
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100429 ret = efi_run_image(image_buf, size);
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900430
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100431 if (ret != EFI_SUCCESS)
432 return CMD_RET_FAILURE;
433
434 return CMD_RET_SUCCESS;
435}
436
437/**
438 * efi_run_image() - run loaded UEFI image
439 *
440 * @source_buffer: memory address of the UEFI image
441 * @source_size: size of the UEFI image
442 * Return: status code
443 */
444efi_status_t efi_run_image(void *source_buffer, efi_uintn_t source_size)
445{
446 efi_handle_t mem_handle = NULL, handle;
447 struct efi_device_path *file_path = NULL;
448 efi_status_t ret;
449
450 if (!bootefi_device_path || !bootefi_image_path) {
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900451 /*
452 * Special case for efi payload not loaded from disk,
453 * such as 'bootefi hello' or for example payload
454 * loaded directly into memory via JTAG, etc:
455 */
456 file_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE,
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100457 (uintptr_t)source_buffer,
458 source_size);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900459 /*
460 * Make sure that device for device_path exist
461 * in load_image(). Otherwise, shell and grub will fail.
462 */
463 ret = efi_create_handle(&mem_handle);
464 if (ret != EFI_SUCCESS)
465 goto out;
466
467 ret = efi_add_protocol(mem_handle, &efi_guid_device_path,
468 file_path);
469 if (ret != EFI_SUCCESS)
470 goto out;
471 } else {
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100472 file_path = efi_dp_append(bootefi_device_path,
473 bootefi_image_path);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900474 }
475
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100476 ret = EFI_CALL(efi_load_image(false, efi_root, file_path, source_buffer,
477 source_size, &handle));
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900478 if (ret != EFI_SUCCESS)
479 goto out;
480
481 ret = do_bootefi_exec(handle);
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900482
483out:
484 if (mem_handle)
485 efi_delete_handle(mem_handle);
486 if (file_path)
487 efi_free_pool(file_path);
Heinrich Schuchardtf9ceb6a2019-12-07 20:51:06 +0100488 return ret;
AKASHI Takahiroe2e40982019-04-19 12:22:34 +0900489}
490
Simon Glassd9717ea2018-11-25 20:14:37 -0700491#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900492static efi_status_t bootefi_run_prepare(const char *load_options_path,
493 struct efi_device_path *device_path,
494 struct efi_device_path *image_path,
495 struct efi_loaded_image_obj **image_objp,
496 struct efi_loaded_image **loaded_image_infop)
497{
498 efi_status_t ret;
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100499 u16 *load_options;
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900500
501 ret = efi_setup_loaded_image(device_path, image_path, image_objp,
502 loaded_image_infop);
503 if (ret != EFI_SUCCESS)
504 return ret;
505
506 /* Transfer environment variable as load options */
Heinrich Schuchardta3850e42020-01-03 22:53:42 +0100507 return set_load_options((efi_handle_t)*image_objp, load_options_path,
508 &load_options);
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900509}
510
Simon Glassd9717ea2018-11-25 20:14:37 -0700511/**
512 * bootefi_test_prepare() - prepare to run an EFI test
513 *
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100514 * Prepare to run a test as if it were provided by a loaded image.
Simon Glassd9717ea2018-11-25 20:14:37 -0700515 *
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100516 * @image_objp: pointer to be set to the loaded image handle
517 * @loaded_image_infop: pointer to be set to the loaded image protocol
518 * @path: dummy file path used to construct the device path
519 * set in the loaded image protocol
520 * @load_options_path: name of a U-Boot environment variable. Its value is
521 * set as load options in the loaded image protocol.
522 * Return: status code
Simon Glassd9717ea2018-11-25 20:14:37 -0700523 */
524static efi_status_t bootefi_test_prepare
525 (struct efi_loaded_image_obj **image_objp,
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100526 struct efi_loaded_image **loaded_image_infop, const char *path,
527 const char *load_options_path)
Simon Glassd9717ea2018-11-25 20:14:37 -0700528{
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100529 efi_status_t ret;
530
Simon Glassd9717ea2018-11-25 20:14:37 -0700531 /* Construct a dummy device path */
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100532 bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, 0, 0);
Simon Glassd9717ea2018-11-25 20:14:37 -0700533 if (!bootefi_device_path)
534 return EFI_OUT_OF_RESOURCES;
Simon Glassd9717ea2018-11-25 20:14:37 -0700535
Heinrich Schuchardt1504bb02019-01-12 14:42:40 +0100536 bootefi_image_path = efi_dp_from_file(NULL, 0, path);
537 if (!bootefi_image_path) {
538 ret = EFI_OUT_OF_RESOURCES;
539 goto failure;
540 }
541
542 ret = bootefi_run_prepare(load_options_path, bootefi_device_path,
543 bootefi_image_path, image_objp,
544 loaded_image_infop);
545 if (ret == EFI_SUCCESS)
546 return ret;
547
548 efi_free_pool(bootefi_image_path);
549 bootefi_image_path = NULL;
550failure:
551 efi_free_pool(bootefi_device_path);
552 bootefi_device_path = NULL;
553 return ret;
Simon Glassd9717ea2018-11-25 20:14:37 -0700554}
555
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900556/**
557 * bootefi_run_finish() - finish up after running an EFI test
558 *
559 * @loaded_image_info: Pointer to a struct which holds the loaded image info
560 * @image_obj: Pointer to a struct which holds the loaded image object
561 */
562static void bootefi_run_finish(struct efi_loaded_image_obj *image_obj,
563 struct efi_loaded_image *loaded_image_info)
564{
565 efi_restore_gd();
566 free(loaded_image_info->load_options);
567 efi_delete_handle(&image_obj->header);
568}
569
570/**
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200571 * do_efi_selftest() - execute EFI selftest
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900572 *
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900573 * Return: status code
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900574 */
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200575static int do_efi_selftest(void)
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900576{
577 struct efi_loaded_image_obj *image_obj;
578 struct efi_loaded_image *loaded_image_info;
579 efi_status_t ret;
580
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900581 ret = bootefi_test_prepare(&image_obj, &loaded_image_info,
582 "\\selftest", "efi_selftest");
583 if (ret != EFI_SUCCESS)
584 return CMD_RET_FAILURE;
585
586 /* Execute the test */
587 ret = EFI_CALL(efi_selftest(&image_obj->header, &systab));
588 bootefi_run_finish(image_obj, loaded_image_info);
589
590 return ret != EFI_SUCCESS;
591}
Simon Glassd9717ea2018-11-25 20:14:37 -0700592#endif /* CONFIG_CMD_BOOTEFI_SELFTEST */
593
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200594/**
595 * do_bootefi() - execute `bootefi` command
596 *
597 * @cmdtp: table entry describing command
598 * @flag: bitmap indicating how the command was invoked
599 * @argc: number of arguments
600 * @argv: command line arguments
601 * Return: status code
602 */
Alexander Grafb9939332016-03-10 00:27:20 +0100603static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
604{
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200605 efi_status_t ret;
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100606 void *fdt;
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200607
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900608 if (argc < 2)
609 return CMD_RET_USAGE;
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900610
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200611 /* Initialize EFI drivers */
612 ret = efi_init_obj_list();
613 if (ret != EFI_SUCCESS) {
614 printf("Error: Cannot initialize UEFI sub-system, r = %lu\n",
615 ret & ~EFI_ERROR_MASK);
616 return CMD_RET_FAILURE;
617 }
618
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100619 if (argc > 2) {
620 uintptr_t fdt_addr;
621
Heinrich Schuchardt7a597252019-11-28 06:46:09 +0100622 fdt_addr = simple_strtoul(argv[2], NULL, 16);
Heinrich Schuchardtf64f2232019-12-08 01:07:01 +0100623 fdt = map_sysmem(fdt_addr, 0);
624 } else {
625 fdt = EFI_FDT_USE_INTERNAL;
626 }
627 ret = efi_install_fdt(fdt);
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200628 if (ret == EFI_INVALID_PARAMETER)
629 return CMD_RET_USAGE;
630 else if (ret != EFI_SUCCESS)
631 return CMD_RET_FAILURE;
632
AKASHI Takahirod6b21892019-04-19 12:22:33 +0900633 if (!strcmp(argv[1], "bootmgr"))
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200634 return do_efibootmgr();
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900635#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
636 else if (!strcmp(argv[1], "selftest"))
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200637 return do_efi_selftest();
AKASHI Takahiro3fc2b162019-04-19 12:22:31 +0900638#endif
639
Heinrich Schuchardt7e92db82019-05-12 20:16:25 +0200640 return do_bootefi_image(argv[1]);
Alexander Grafb9939332016-03-10 00:27:20 +0100641}
642
643#ifdef CONFIG_SYS_LONGHELP
644static char bootefi_help_text[] =
Alexander Graf1c398092016-04-14 16:07:53 +0200645 "<image address> [fdt address]\n"
646 " - boot EFI payload stored at address <image address>.\n"
647 " If specified, the device tree located at <fdt address> gets\n"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700648 " exposed as EFI configuration table.\n"
649#ifdef CONFIG_CMD_BOOTEFI_HELLO
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200650 "bootefi hello\n"
651 " - boot a sample Hello World application stored within U-Boot\n"
652#endif
653#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100654 "bootefi selftest [fdt address]\n"
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200655 " - boot an EFI selftest application stored within U-Boot\n"
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200656 " Use environment variable efi_selftest to select a single test.\n"
657 " Use 'setenv efi_selftest list' to enumerate all tests.\n"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700658#endif
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900659 "bootefi bootmgr [fdt address]\n"
Rob Clark9975fe92017-09-13 18:05:38 -0400660 " - load and boot EFI payload based on BootOrder/BootXXXX variables.\n"
661 "\n"
662 " If specified, the device tree located at <fdt address> gets\n"
663 " exposed as EFI configuration table.\n";
Alexander Grafb9939332016-03-10 00:27:20 +0100664#endif
665
666U_BOOT_CMD(
Alexander Graf1c398092016-04-14 16:07:53 +0200667 bootefi, 3, 0, do_bootefi,
Sergey Kubushyn92dfd922016-06-07 11:14:31 -0700668 "Boots an EFI payload from memory",
Alexander Grafb9939332016-03-10 00:27:20 +0100669 bootefi_help_text
670);
Alexander Graf0f4060e2016-03-04 01:10:14 +0100671
Heinrich Schuchardt810371a2019-07-14 13:00:44 +0200672/**
673 * efi_set_bootdev() - set boot device
674 *
675 * This function is called when a file is loaded, e.g. via the 'load' command.
676 * We use the path to this file to inform the UEFI binary about the boot device.
677 *
678 * @dev: device, e.g. "MMC"
679 * @devnr: number of the device, e.g. "1:2"
680 * @path: path to file loaded
681 */
Alexander Grafc07ad7c2016-04-11 16:16:19 +0200682void efi_set_bootdev(const char *dev, const char *devnr, const char *path)
Alexander Graf0f4060e2016-03-04 01:10:14 +0100683{
AKASHI Takahirof1589ff2018-10-17 16:32:03 +0900684 struct efi_device_path *device, *image;
685 efi_status_t ret;
Alexander Graf0f4060e2016-03-04 01:10:14 +0100686
Heinrich Schuchardt79276eb2018-09-16 07:20:21 +0200687 /* efi_set_bootdev is typically called repeatedly, recover memory */
688 efi_free_pool(bootefi_device_path);
689 efi_free_pool(bootefi_image_path);
Heinrich Schuchardt79276eb2018-09-16 07:20:21 +0200690
AKASHI Takahirof1589ff2018-10-17 16:32:03 +0900691 ret = efi_dp_from_name(dev, devnr, path, &device, &image);
692 if (ret == EFI_SUCCESS) {
693 bootefi_device_path = device;
AKASHI Takahiro6b95b382019-04-19 12:22:35 +0900694 if (image) {
695 /* FIXME: image should not contain device */
696 struct efi_device_path *image_tmp = image;
697
698 efi_dp_split_file_path(image, &device, &image);
699 efi_free_pool(image_tmp);
700 }
AKASHI Takahirof1589ff2018-10-17 16:32:03 +0900701 bootefi_image_path = image;
Rob Clark95c55532017-09-13 18:05:33 -0400702 } else {
AKASHI Takahirof1589ff2018-10-17 16:32:03 +0900703 bootefi_device_path = NULL;
704 bootefi_image_path = NULL;
Alexander Graff9d334b2016-08-05 14:49:53 +0200705 }
Alexander Graf0f4060e2016-03-04 01:10:14 +0100706}