blob: cd755b6bf44441a9d25ff0356a9d10066f9e4c56 [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 Schuchardtd78e40d2017-10-18 18:13:13 +02008#include <charset.h>
Alexander Grafb9939332016-03-10 00:27:20 +01009#include <common.h>
10#include <command.h>
Simon Glass9d922452017-05-17 17:18:03 -060011#include <dm.h>
Alexander Grafb9939332016-03-10 00:27:20 +010012#include <efi_loader.h>
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020013#include <efi_selftest.h>
Alexander Grafb9939332016-03-10 00:27:20 +010014#include <errno.h>
Masahiro Yamadab08c8c42018-03-05 01:20:11 +090015#include <linux/libfdt.h>
16#include <linux/libfdt_env.h>
Alexander Grafad0c1a32016-04-11 23:51:01 +020017#include <memalign.h>
Alexander Graf0d9d5012016-04-11 16:55:26 +020018#include <asm/global_data.h>
Simon Glasse2754582016-09-25 15:27:32 -060019#include <asm-generic/sections.h>
Heinrich Schuchardtc3b11de2018-04-03 21:59:32 +020020#include <asm-generic/unaligned.h>
Simon Glasse2754582016-09-25 15:27:32 -060021#include <linux/linkage.h>
Alexander Graf0d9d5012016-04-11 16:55:26 +020022
23DECLARE_GLOBAL_DATA_PTR;
Alexander Grafb9939332016-03-10 00:27:20 +010024
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010025#define OBJ_LIST_NOT_INITIALIZED 1
26
27static efi_status_t efi_obj_list_initialized = OBJ_LIST_NOT_INITIALIZED;
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020028
Rob Clark95c55532017-09-13 18:05:33 -040029static struct efi_device_path *bootefi_image_path;
30static struct efi_device_path *bootefi_device_path;
Alexander Grafb9939332016-03-10 00:27:20 +010031
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020032/* Initialize and populate EFI object list */
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010033efi_status_t efi_init_obj_list(void)
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020034{
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010035 efi_status_t ret = EFI_SUCCESS;
36
Heinrich Schuchardt098a6cd2018-03-03 15:28:58 +010037 /* Initialize once only */
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010038 if (efi_obj_list_initialized != OBJ_LIST_NOT_INITIALIZED)
39 return efi_obj_list_initialized;
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020040
Heinrich Schuchardt05ef48a2018-01-21 19:29:30 +010041 /* Initialize EFI driver uclass */
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010042 ret = efi_driver_init();
43 if (ret != EFI_SUCCESS)
44 goto out;
Heinrich Schuchardt05ef48a2018-01-21 19:29:30 +010045
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010046 ret = efi_console_register();
47 if (ret != EFI_SUCCESS)
48 goto out;
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020049#ifdef CONFIG_PARTITIONS
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010050 ret = efi_disk_register();
51 if (ret != EFI_SUCCESS)
52 goto out;
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020053#endif
54#if defined(CONFIG_LCD) || defined(CONFIG_DM_VIDEO)
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010055 ret = efi_gop_register();
56 if (ret != EFI_SUCCESS)
57 goto out;
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020058#endif
Joe Hershberger092f2f32018-04-13 15:26:39 -050059#ifdef CONFIG_NET
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010060 ret = efi_net_register();
61 if (ret != EFI_SUCCESS)
62 goto out;
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020063#endif
Bin Meng86df34d2018-06-27 20:38:03 -070064#ifdef CONFIG_GENERATE_ACPI_TABLE
65 ret = efi_acpi_register();
66 if (ret != EFI_SUCCESS)
67 goto out;
68#endif
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020069#ifdef CONFIG_GENERATE_SMBIOS_TABLE
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010070 ret = efi_smbios_register();
71 if (ret != EFI_SUCCESS)
72 goto out;
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020073#endif
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010074 ret = efi_watchdog_register();
75 if (ret != EFI_SUCCESS)
76 goto out;
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020077
78 /* Initialize EFI runtime services */
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +010079 ret = efi_reset_system_init();
80 if (ret != EFI_SUCCESS)
81 goto out;
82 ret = efi_get_time_init();
83 if (ret != EFI_SUCCESS)
84 goto out;
85
86out:
87 efi_obj_list_initialized = ret;
88 return ret;
Heinrich Schuchardt7cbc1242017-07-19 19:37:22 +020089}
90
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +020091/*
Heinrich Schuchardtc3b11de2018-04-03 21:59:32 +020092 * Allow unaligned memory access.
93 *
94 * This routine is overridden by architectures providing this feature.
95 */
96void __weak allow_unaligned(void)
97{
98}
99
100/*
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200101 * Set the load options of an image from an environment variable.
102 *
103 * @loaded_image_info: the image
104 * @env_var: name of the environment variable
105 */
106static void set_load_options(struct efi_loaded_image *loaded_image_info,
107 const char *env_var)
108{
109 size_t size;
110 const char *env = env_get(env_var);
111
112 loaded_image_info->load_options = NULL;
113 loaded_image_info->load_options_size = 0;
114 if (!env)
115 return;
116 size = strlen(env) + 1;
117 loaded_image_info->load_options = calloc(size, sizeof(u16));
118 if (!loaded_image_info->load_options) {
119 printf("ERROR: Out of memory\n");
120 return;
121 }
122 utf8_to_utf16(loaded_image_info->load_options, (u8 *)env, size);
123 loaded_image_info->load_options_size = size * 2;
124}
125
Alexander Graf0d9d5012016-04-11 16:55:26 +0200126static void *copy_fdt(void *fdt)
127{
128 u64 fdt_size = fdt_totalsize(fdt);
Alexander Grafad0c1a32016-04-11 23:51:01 +0200129 unsigned long fdt_ram_start = -1L, fdt_pages;
130 u64 new_fdt_addr;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200131 void *new_fdt;
Alexander Grafad0c1a32016-04-11 23:51:01 +0200132 int i;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200133
Alexander Grafad0c1a32016-04-11 23:51:01 +0200134 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
135 u64 ram_start = gd->bd->bi_dram[i].start;
136 u64 ram_size = gd->bd->bi_dram[i].size;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200137
Alexander Grafad0c1a32016-04-11 23:51:01 +0200138 if (!ram_size)
139 continue;
140
141 if (ram_start < fdt_ram_start)
142 fdt_ram_start = ram_start;
143 }
144
145 /* Give us at least 4kb breathing room */
xypron.glpk@gmx.dea44bffc2017-08-11 21:19:25 +0200146 fdt_size = ALIGN(fdt_size + 4096, EFI_PAGE_SIZE);
Alexander Grafad0c1a32016-04-11 23:51:01 +0200147 fdt_pages = fdt_size >> EFI_PAGE_SHIFT;
148
149 /* Safe fdt location is at 128MB */
150 new_fdt_addr = fdt_ram_start + (128 * 1024 * 1024) + fdt_size;
Heinrich Schuchardte09159c2018-05-26 10:32:27 +0200151 if (efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
152 EFI_RUNTIME_SERVICES_DATA, fdt_pages,
Alexander Grafad0c1a32016-04-11 23:51:01 +0200153 &new_fdt_addr) != EFI_SUCCESS) {
154 /* If we can't put it there, put it somewhere */
xypron.glpk@gmx.dea44bffc2017-08-11 21:19:25 +0200155 new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size);
Heinrich Schuchardte09159c2018-05-26 10:32:27 +0200156 if (efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
157 EFI_RUNTIME_SERVICES_DATA, fdt_pages,
Alexander Graf85a6e9b2017-07-03 13:32:35 +0200158 &new_fdt_addr) != EFI_SUCCESS) {
159 printf("ERROR: Failed to reserve space for FDT\n");
160 return NULL;
161 }
Alexander Grafad0c1a32016-04-11 23:51:01 +0200162 }
Alexander Graf85a6e9b2017-07-03 13:32:35 +0200163
Alexander Grafad0c1a32016-04-11 23:51:01 +0200164 new_fdt = (void*)(ulong)new_fdt_addr;
Alexander Graf0d9d5012016-04-11 16:55:26 +0200165 memcpy(new_fdt, fdt, fdt_totalsize(fdt));
166 fdt_set_totalsize(new_fdt, fdt_size);
167
168 return new_fdt;
169}
170
Heinrich Schuchardt3eb08412017-10-18 18:13:08 +0200171static efi_status_t efi_do_enter(
Heinrich Schuchardt2074f702018-01-11 08:16:09 +0100172 efi_handle_t image_handle, struct efi_system_table *st,
Alexander Grafc6fa5df2018-01-24 00:18:08 +0100173 EFIAPI efi_status_t (*entry)(
174 efi_handle_t image_handle,
175 struct efi_system_table *st))
xypron.glpk@gmx.deb06d8ac2017-07-04 23:15:21 +0200176{
177 efi_status_t ret = EFI_LOAD_ERROR;
178
179 if (entry)
180 ret = entry(image_handle, st);
181 st->boottime->exit(image_handle, ret, 0, NULL);
182 return ret;
183}
184
Alison Wangec6617c2016-11-10 10:49:03 +0800185#ifdef CONFIG_ARM64
Alexander Grafc6fa5df2018-01-24 00:18:08 +0100186static efi_status_t efi_run_in_el2(EFIAPI efi_status_t (*entry)(
Heinrich Schuchardt2074f702018-01-11 08:16:09 +0100187 efi_handle_t image_handle, struct efi_system_table *st),
188 efi_handle_t image_handle, struct efi_system_table *st)
Alison Wangec6617c2016-11-10 10:49:03 +0800189{
190 /* Enable caches again */
191 dcache_enable();
192
xypron.glpk@gmx.deb06d8ac2017-07-04 23:15:21 +0200193 return efi_do_enter(image_handle, st, entry);
Alison Wangec6617c2016-11-10 10:49:03 +0800194}
195#endif
196
Alexander Graf806d2fa2018-04-06 09:40:51 +0200197/* Carve out DT reserved memory ranges */
198static efi_status_t efi_carve_out_dt_rsv(void *fdt)
199{
200 int nr_rsv, i;
201 uint64_t addr, size, pages;
202
203 nr_rsv = fdt_num_mem_rsv(fdt);
204
205 /* Look for an existing entry and add it to the efi mem map. */
206 for (i = 0; i < nr_rsv; i++) {
207 if (fdt_get_mem_rsv(fdt, i, &addr, &size) != 0)
208 continue;
209
210 pages = ALIGN(size, EFI_PAGE_SIZE) >> EFI_PAGE_SHIFT;
211 efi_add_memory_map(addr, pages, EFI_RESERVED_MEMORY_TYPE,
212 false);
213 }
214
215 return EFI_SUCCESS;
216}
217
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100218static efi_status_t efi_install_fdt(void *fdt)
219{
220 bootm_headers_t img = { 0 };
221 ulong fdt_pages, fdt_size, fdt_start, fdt_end;
222 efi_status_t ret;
223
224 if (fdt_check_header(fdt)) {
225 printf("ERROR: invalid device tree\n");
226 return EFI_INVALID_PARAMETER;
227 }
228
229 /* Prepare fdt for payload */
230 fdt = copy_fdt(fdt);
231 if (!fdt)
232 return EFI_OUT_OF_RESOURCES;
233
234 if (image_setup_libfdt(&img, fdt, 0, NULL)) {
235 printf("ERROR: failed to process device tree\n");
236 return EFI_LOAD_ERROR;
237 }
238
Alexander Graf806d2fa2018-04-06 09:40:51 +0200239 if (efi_carve_out_dt_rsv(fdt) != EFI_SUCCESS) {
240 printf("ERROR: failed to carve out memory\n");
241 return EFI_LOAD_ERROR;
242 }
243
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100244 /* Link to it in the efi tables */
245 ret = efi_install_configuration_table(&efi_guid_fdt, fdt);
246 if (ret != EFI_SUCCESS)
247 return EFI_OUT_OF_RESOURCES;
248
249 /* And reserve the space in the memory map */
250 fdt_start = ((ulong)fdt) & ~EFI_PAGE_MASK;
251 fdt_end = ((ulong)fdt) + fdt_totalsize(fdt);
252 fdt_size = (fdt_end - fdt_start) + EFI_PAGE_MASK;
253 fdt_pages = fdt_size >> EFI_PAGE_SHIFT;
254 /* Give a bootloader the chance to modify the device tree */
255 fdt_pages += 2;
256 ret = efi_add_memory_map(fdt_start, fdt_pages,
257 EFI_BOOT_SERVICES_DATA, true);
258 return ret;
259}
260
Alexander Grafb9939332016-03-10 00:27:20 +0100261/*
262 * Load an EFI payload into a newly allocated piece of memory, register all
263 * EFI objects it would want to access and jump to it.
264 */
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100265static efi_status_t do_bootefi_exec(void *efi,
Heinrich Schuchardt3eb08412017-10-18 18:13:08 +0200266 struct efi_device_path *device_path,
267 struct efi_device_path *image_path)
Alexander Grafb9939332016-03-10 00:27:20 +0100268{
Rob Clark95c55532017-09-13 18:05:33 -0400269 struct efi_loaded_image loaded_image_info = {};
270 struct efi_object loaded_image_info_obj = {};
Alexander Graf58bc69d2018-06-12 10:21:16 +0200271 struct efi_object mem_obj = {};
Rob Clarkbf192732017-10-10 08:23:06 -0400272 struct efi_device_path *memdp = NULL;
Heinrich Schuchardt45204b12018-03-03 15:29:01 +0100273 efi_status_t ret;
Rob Clark95c55532017-09-13 18:05:33 -0400274
Alexander Grafc6fa5df2018-01-24 00:18:08 +0100275 EFIAPI efi_status_t (*entry)(efi_handle_t image_handle,
276 struct efi_system_table *st);
Alexander Grafb9939332016-03-10 00:27:20 +0100277
Rob Clarkbf192732017-10-10 08:23:06 -0400278 /*
279 * Special case for efi payload not loaded from disk, such as
280 * 'bootefi hello' or for example payload loaded directly into
281 * memory via jtag/etc:
282 */
283 if (!device_path && !image_path) {
284 printf("WARNING: using memory device/image path, this may confuse some payloads!\n");
285 /* actual addresses filled in after efi_load_pe() */
286 memdp = efi_dp_from_mem(0, 0, 0);
287 device_path = image_path = memdp;
Alexander Graf58bc69d2018-06-12 10:21:16 +0200288 efi_add_handle(&mem_obj);
289
290 ret = efi_add_protocol(mem_obj.handle, &efi_guid_device_path,
291 device_path);
292 if (ret != EFI_SUCCESS)
293 goto exit;
Rob Clarkbf192732017-10-10 08:23:06 -0400294 } else {
295 assert(device_path && image_path);
296 }
297
Rob Clark95c55532017-09-13 18:05:33 -0400298 efi_setup_loaded_image(&loaded_image_info, &loaded_image_info_obj,
299 device_path, image_path);
300
Alexander Grafb9939332016-03-10 00:27:20 +0100301 /*
302 * gd lives in a fixed register which may get clobbered while we execute
303 * the payload. So save it here and restore it on every callback entry
304 */
305 efi_save_gd();
306
Heinrich Schuchardtb57f48a2017-10-18 18:13:15 +0200307 /* Transfer environment variable bootargs as load options */
308 set_load_options(&loaded_image_info, "bootargs");
Alexander Grafb9939332016-03-10 00:27:20 +0100309 /* Load the EFI payload */
310 entry = efi_load_pe(efi, &loaded_image_info);
Rob Clark95c55532017-09-13 18:05:33 -0400311 if (!entry) {
Heinrich Schuchardt45204b12018-03-03 15:29:01 +0100312 ret = EFI_LOAD_ERROR;
Rob Clark95c55532017-09-13 18:05:33 -0400313 goto exit;
314 }
Alexander Graf80a48002016-08-16 21:08:45 +0200315
Rob Clarkbf192732017-10-10 08:23:06 -0400316 if (memdp) {
317 struct efi_device_path_memory *mdp = (void *)memdp;
318 mdp->memory_type = loaded_image_info.image_code_type;
319 mdp->start_address = (uintptr_t)loaded_image_info.image_base;
320 mdp->end_address = mdp->start_address +
321 loaded_image_info.image_size;
322 }
323
Rob Clarkad644e72017-09-13 18:05:37 -0400324 /* we don't support much: */
325 env_set("efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported",
326 "{ro,boot}(blob)0000000000000000");
327
Alexander Grafb9939332016-03-10 00:27:20 +0100328 /* Call our payload! */
Alexander Grafedcef3b2016-06-02 11:38:27 +0200329 debug("%s:%d Jumping to 0x%lx\n", __func__, __LINE__, (long)entry);
Alexander Grafa86aeaf2016-05-20 23:28:23 +0200330
331 if (setjmp(&loaded_image_info.exit_jmp)) {
Rob Clark95c55532017-09-13 18:05:33 -0400332 ret = loaded_image_info.exit_status;
Rob Clark95c55532017-09-13 18:05:33 -0400333 goto exit;
Alexander Grafa86aeaf2016-05-20 23:28:23 +0200334 }
335
Alexander Graf69bd4592016-11-17 01:02:58 +0100336#ifdef CONFIG_ARM64
337 /* On AArch64 we need to make sure we call our payload in < EL3 */
338 if (current_el() == 3) {
339 smp_kick_all_cpus();
340 dcache_disable(); /* flush cache before switch to EL2 */
Alison Wangec6617c2016-11-10 10:49:03 +0800341
342 /* Move into EL2 and keep running there */
Heinrich Schuchardtea54ad52017-11-26 14:05:22 +0100343 armv8_switch_to_el2((ulong)entry,
344 (ulong)&loaded_image_info_obj.handle,
Alison Wang7c5e1fe2017-01-17 09:39:17 +0800345 (ulong)&systab, 0, (ulong)efi_run_in_el2,
Alison Wangec6617c2016-11-10 10:49:03 +0800346 ES_TO_AARCH64);
347
348 /* Should never reach here, efi exits with longjmp */
349 while (1) { }
Alexander Graf69bd4592016-11-17 01:02:58 +0100350 }
351#endif
352
Heinrich Schuchardtea54ad52017-11-26 14:05:22 +0100353 ret = efi_do_enter(loaded_image_info_obj.handle, &systab, entry);
Rob Clark95c55532017-09-13 18:05:33 -0400354
355exit:
356 /* image has returned, loaded-image obj goes *poof*: */
357 list_del(&loaded_image_info_obj.link);
Alexander Graf58bc69d2018-06-12 10:21:16 +0200358 if (mem_obj.handle)
359 list_del(&mem_obj.link);
Rob Clark95c55532017-09-13 18:05:33 -0400360
361 return ret;
Alexander Grafb9939332016-03-10 00:27:20 +0100362}
363
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100364static int do_bootefi_bootmgr_exec(void)
Rob Clark9975fe92017-09-13 18:05:38 -0400365{
366 struct efi_device_path *device_path, *file_path;
367 void *addr;
368 efi_status_t r;
369
Rob Clark9975fe92017-09-13 18:05:38 -0400370 /*
371 * gd lives in a fixed register which may get clobbered while we execute
372 * the payload. So save it here and restore it on every callback entry
373 */
374 efi_save_gd();
375
376 addr = efi_bootmgr_load(&device_path, &file_path);
377 if (!addr)
378 return 1;
379
380 printf("## Starting EFI application at %p ...\n", addr);
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100381 r = do_bootefi_exec(addr, device_path, file_path);
Rob Clark9975fe92017-09-13 18:05:38 -0400382 printf("## Application terminated, r = %lu\n",
383 r & ~EFI_ERROR_MASK);
384
385 if (r != EFI_SUCCESS)
386 return 1;
387
388 return 0;
389}
390
Alexander Grafb9939332016-03-10 00:27:20 +0100391/* Interpreter command to boot an arbitrary EFI image from memory */
392static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
393{
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100394 unsigned long addr;
395 char *saddr;
Heinrich Schuchardt3eb08412017-10-18 18:13:08 +0200396 efi_status_t r;
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100397 void *fdt_addr;
Alexander Grafb9939332016-03-10 00:27:20 +0100398
Heinrich Schuchardtc3b11de2018-04-03 21:59:32 +0200399 /* Allow unaligned memory access */
400 allow_unaligned();
401
Heinrich Schuchardtfc225e62018-03-03 15:29:02 +0100402 /* Initialize EFI drivers */
403 r = efi_init_obj_list();
404 if (r != EFI_SUCCESS) {
405 printf("Error: Cannot set up EFI drivers, r = %lu\n",
406 r & ~EFI_ERROR_MASK);
407 return CMD_RET_FAILURE;
408 }
409
Alexander Grafb9939332016-03-10 00:27:20 +0100410 if (argc < 2)
Bin Meng3c1dcef2016-08-13 04:02:06 -0700411 return CMD_RET_USAGE;
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100412
413 if (argc > 2) {
414 fdt_addr = (void *)simple_strtoul(argv[2], NULL, 16);
415 if (!fdt_addr && *argv[2] != '0')
416 return CMD_RET_USAGE;
417 /* Install device tree */
418 r = efi_install_fdt(fdt_addr);
419 if (r != EFI_SUCCESS) {
420 printf("ERROR: failed to install device tree\n");
421 return CMD_RET_FAILURE;
422 }
423 } else {
424 /* Remove device tree. EFI_NOT_FOUND can be ignored here */
425 efi_install_configuration_table(&efi_guid_fdt, NULL);
426 printf("WARNING: booting without device tree\n");
427 }
Simon Glassc7ae3df2016-11-07 08:47:08 -0700428#ifdef CONFIG_CMD_BOOTEFI_HELLO
429 if (!strcmp(argv[1], "hello")) {
Heinrich Schuchardt5e444892017-09-05 03:19:37 +0200430 ulong size = __efi_helloworld_end - __efi_helloworld_begin;
Alexander Grafb9939332016-03-10 00:27:20 +0100431
Heinrich Schuchardt51c533f2017-08-28 18:54:30 +0200432 saddr = env_get("loadaddr");
433 if (saddr)
434 addr = simple_strtoul(saddr, NULL, 16);
435 else
436 addr = CONFIG_SYS_LOAD_ADDR;
Heinrich Schuchardt5e444892017-09-05 03:19:37 +0200437 memcpy((char *)addr, __efi_helloworld_begin, size);
Simon Glassc7ae3df2016-11-07 08:47:08 -0700438 } else
439#endif
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200440#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
441 if (!strcmp(argv[1], "selftest")) {
Heinrich Schuchardt7aca68c2017-09-20 22:54:58 +0200442 struct efi_loaded_image loaded_image_info = {};
443 struct efi_object loaded_image_info_obj = {};
444
Heinrich Schuchardtf972dc12017-10-18 18:13:09 +0200445 /* Construct a dummy device path. */
446 bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE,
447 (uintptr_t)&efi_selftest,
448 (uintptr_t)&efi_selftest);
449 bootefi_image_path = efi_dp_from_file(NULL, 0, "\\selftest");
450
Heinrich Schuchardt7aca68c2017-09-20 22:54:58 +0200451 efi_setup_loaded_image(&loaded_image_info,
452 &loaded_image_info_obj,
453 bootefi_device_path, bootefi_image_path);
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200454 /*
455 * gd lives in a fixed register which may get clobbered while we
456 * execute the payload. So save it here and restore it on every
457 * callback entry
458 */
459 efi_save_gd();
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200460 /* Transfer environment variable efi_selftest as load options */
461 set_load_options(&loaded_image_info, "efi_selftest");
462 /* Execute the test */
Heinrich Schuchardtea54ad52017-11-26 14:05:22 +0100463 r = efi_selftest(loaded_image_info_obj.handle, &systab);
Heinrich Schuchardtc2b53902017-10-18 18:13:14 +0200464 efi_restore_gd();
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200465 free(loaded_image_info.load_options);
Heinrich Schuchardtc2b53902017-10-18 18:13:14 +0200466 list_del(&loaded_image_info_obj.link);
467 return r != EFI_SUCCESS;
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200468 } else
469#endif
Rob Clark9975fe92017-09-13 18:05:38 -0400470 if (!strcmp(argv[1], "bootmgr")) {
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100471 return do_bootefi_bootmgr_exec();
Rob Clark9975fe92017-09-13 18:05:38 -0400472 } else {
Simon Glassc7ae3df2016-11-07 08:47:08 -0700473 saddr = argv[1];
Alexander Grafb9939332016-03-10 00:27:20 +0100474
Simon Glassc7ae3df2016-11-07 08:47:08 -0700475 addr = simple_strtoul(saddr, NULL, 16);
Heinrich Schuchardt49db1cb2018-01-24 20:33:54 +0100476 /* Check that a numeric value was passed */
477 if (!addr && *saddr != '0')
478 return CMD_RET_USAGE;
Simon Glassc7ae3df2016-11-07 08:47:08 -0700479
Alexander Graf1c398092016-04-14 16:07:53 +0200480 }
481
Simon Glass5ee31ba2016-11-07 08:47:05 -0700482 printf("## Starting EFI application at %08lx ...\n", addr);
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100483 r = do_bootefi_exec((void *)addr, bootefi_device_path,
484 bootefi_image_path);
xypron.glpk@gmx.de1da1bac2017-07-04 23:15:23 +0200485 printf("## Application terminated, r = %lu\n",
486 r & ~EFI_ERROR_MASK);
Alexander Grafb9939332016-03-10 00:27:20 +0100487
xypron.glpk@gmx.de1da1bac2017-07-04 23:15:23 +0200488 if (r != EFI_SUCCESS)
489 return 1;
490 else
491 return 0;
Alexander Grafb9939332016-03-10 00:27:20 +0100492}
493
494#ifdef CONFIG_SYS_LONGHELP
495static char bootefi_help_text[] =
Alexander Graf1c398092016-04-14 16:07:53 +0200496 "<image address> [fdt address]\n"
497 " - boot EFI payload stored at address <image address>.\n"
498 " If specified, the device tree located at <fdt address> gets\n"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700499 " exposed as EFI configuration table.\n"
500#ifdef CONFIG_CMD_BOOTEFI_HELLO
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200501 "bootefi hello\n"
502 " - boot a sample Hello World application stored within U-Boot\n"
503#endif
504#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
Heinrich Schuchardtbc4f9132018-03-03 15:29:03 +0100505 "bootefi selftest [fdt address]\n"
Heinrich Schuchardt623b3a52017-09-15 10:06:11 +0200506 " - boot an EFI selftest application stored within U-Boot\n"
Heinrich Schuchardtd78e40d2017-10-18 18:13:13 +0200507 " Use environment variable efi_selftest to select a single test.\n"
508 " Use 'setenv efi_selftest list' to enumerate all tests.\n"
Simon Glassc7ae3df2016-11-07 08:47:08 -0700509#endif
Heinrich Schuchardtf623e072018-01-30 19:47:43 +0100510 "bootefi bootmgr [fdt addr]\n"
Rob Clark9975fe92017-09-13 18:05:38 -0400511 " - load and boot EFI payload based on BootOrder/BootXXXX variables.\n"
512 "\n"
513 " If specified, the device tree located at <fdt address> gets\n"
514 " exposed as EFI configuration table.\n";
Alexander Grafb9939332016-03-10 00:27:20 +0100515#endif
516
517U_BOOT_CMD(
Alexander Graf1c398092016-04-14 16:07:53 +0200518 bootefi, 3, 0, do_bootefi,
Sergey Kubushyn92dfd922016-06-07 11:14:31 -0700519 "Boots an EFI payload from memory",
Alexander Grafb9939332016-03-10 00:27:20 +0100520 bootefi_help_text
521);
Alexander Graf0f4060e2016-03-04 01:10:14 +0100522
Alexander Grafc07ad7c2016-04-11 16:16:19 +0200523void efi_set_bootdev(const char *dev, const char *devnr, const char *path)
Alexander Graf0f4060e2016-03-04 01:10:14 +0100524{
Rob Clark95c55532017-09-13 18:05:33 -0400525 char filename[32] = { 0 }; /* dp->str is u16[32] long */
526 char *s;
Alexander Graf0f4060e2016-03-04 01:10:14 +0100527
Rob Clark95c55532017-09-13 18:05:33 -0400528 if (strcmp(dev, "Net")) {
529 struct blk_desc *desc;
Heinrich Schuchardt2db1eba2018-04-03 22:40:55 +0200530 disk_partition_t fs_partition;
Rob Clark95c55532017-09-13 18:05:33 -0400531 int part;
532
Heinrich Schuchardt2db1eba2018-04-03 22:40:55 +0200533 part = blk_get_device_part_str(dev, devnr, &desc, &fs_partition,
534 1);
535 if (part < 0)
Stefan Roese8300be62017-11-17 08:47:09 +0100536 return;
Rob Clark95c55532017-09-13 18:05:33 -0400537
538 bootefi_device_path = efi_dp_from_part(desc, part);
539 } else {
Joe Hershberger092f2f32018-04-13 15:26:39 -0500540#ifdef CONFIG_NET
Rob Clark95c55532017-09-13 18:05:33 -0400541 bootefi_device_path = efi_dp_from_eth();
Alexander Graff9d334b2016-08-05 14:49:53 +0200542#endif
Alexander Graff9d334b2016-08-05 14:49:53 +0200543 }
544
Rob Clark9975fe92017-09-13 18:05:38 -0400545 if (!path)
546 return;
547
Alexander Graf49271662016-07-21 01:44:46 +0200548 if (strcmp(dev, "Net")) {
549 /* Add leading / to fs paths, because they're absolute */
Rob Clark95c55532017-09-13 18:05:33 -0400550 snprintf(filename, sizeof(filename), "/%s", path);
Alexander Graf49271662016-07-21 01:44:46 +0200551 } else {
Rob Clark95c55532017-09-13 18:05:33 -0400552 snprintf(filename, sizeof(filename), "%s", path);
Alexander Graf49271662016-07-21 01:44:46 +0200553 }
Rob Clark3e433e92017-07-24 07:59:09 -0400554 /* DOS style file path: */
Rob Clark95c55532017-09-13 18:05:33 -0400555 s = filename;
Rob Clark3e433e92017-07-24 07:59:09 -0400556 while ((s = strchr(s, '/')))
557 *s++ = '\\';
Rob Clark95c55532017-09-13 18:05:33 -0400558 bootefi_image_path = efi_dp_from_file(NULL, 0, filename);
Alexander Graf0f4060e2016-03-04 01:10:14 +0100559}