2018-05-08 06:02:21 +09:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2016-03-10 08:27:20 +09:00
|
|
|
/*
|
|
|
|
* EFI application loader
|
|
|
|
*
|
|
|
|
* Copyright (c) 2016 Alexander Graf
|
|
|
|
*/
|
|
|
|
|
2017-10-19 01:13:13 +09:00
|
|
|
#include <charset.h>
|
2016-03-10 08:27:20 +09:00
|
|
|
#include <common.h>
|
|
|
|
#include <command.h>
|
2017-05-18 08:18:03 +09:00
|
|
|
#include <dm.h>
|
2016-03-10 08:27:20 +09:00
|
|
|
#include <efi_loader.h>
|
2017-10-19 01:13:13 +09:00
|
|
|
#include <efi_selftest.h>
|
2016-03-10 08:27:20 +09:00
|
|
|
#include <errno.h>
|
2018-03-05 01:20:11 +09:00
|
|
|
#include <linux/libfdt.h>
|
|
|
|
#include <linux/libfdt_env.h>
|
2016-04-12 06:51:01 +09:00
|
|
|
#include <memalign.h>
|
2016-04-11 23:55:26 +09:00
|
|
|
#include <asm/global_data.h>
|
2016-09-26 06:27:32 +09:00
|
|
|
#include <asm-generic/sections.h>
|
2018-04-04 04:59:32 +09:00
|
|
|
#include <asm-generic/unaligned.h>
|
2016-09-26 06:27:32 +09:00
|
|
|
#include <linux/linkage.h>
|
2016-04-11 23:55:26 +09:00
|
|
|
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2018-03-03 23:29:02 +09:00
|
|
|
#define OBJ_LIST_NOT_INITIALIZED 1
|
|
|
|
|
|
|
|
static efi_status_t efi_obj_list_initialized = OBJ_LIST_NOT_INITIALIZED;
|
2017-07-20 02:37:22 +09:00
|
|
|
|
2017-09-14 07:05:33 +09:00
|
|
|
static struct efi_device_path *bootefi_image_path;
|
|
|
|
static struct efi_device_path *bootefi_device_path;
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2017-07-20 02:37:22 +09:00
|
|
|
/* Initialize and populate EFI object list */
|
2018-03-03 23:29:02 +09:00
|
|
|
efi_status_t efi_init_obj_list(void)
|
2017-07-20 02:37:22 +09:00
|
|
|
{
|
2018-03-03 23:29:02 +09:00
|
|
|
efi_status_t ret = EFI_SUCCESS;
|
|
|
|
|
2018-03-03 23:28:58 +09:00
|
|
|
/* Initialize once only */
|
2018-03-03 23:29:02 +09:00
|
|
|
if (efi_obj_list_initialized != OBJ_LIST_NOT_INITIALIZED)
|
|
|
|
return efi_obj_list_initialized;
|
2017-07-20 02:37:22 +09:00
|
|
|
|
2018-01-22 03:29:30 +09:00
|
|
|
/* Initialize EFI driver uclass */
|
2018-03-03 23:29:02 +09:00
|
|
|
ret = efi_driver_init();
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
goto out;
|
2018-01-22 03:29:30 +09:00
|
|
|
|
2018-03-03 23:29:02 +09:00
|
|
|
ret = efi_console_register();
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
goto out;
|
2017-07-20 02:37:22 +09:00
|
|
|
#ifdef CONFIG_PARTITIONS
|
2018-03-03 23:29:02 +09:00
|
|
|
ret = efi_disk_register();
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
goto out;
|
2017-07-20 02:37:22 +09:00
|
|
|
#endif
|
|
|
|
#if defined(CONFIG_LCD) || defined(CONFIG_DM_VIDEO)
|
2018-03-03 23:29:02 +09:00
|
|
|
ret = efi_gop_register();
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
goto out;
|
2017-07-20 02:37:22 +09:00
|
|
|
#endif
|
2018-04-14 05:26:39 +09:00
|
|
|
#ifdef CONFIG_NET
|
2018-03-03 23:29:02 +09:00
|
|
|
ret = efi_net_register();
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
goto out;
|
2017-07-20 02:37:22 +09:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_GENERATE_SMBIOS_TABLE
|
2018-03-03 23:29:02 +09:00
|
|
|
ret = efi_smbios_register();
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
goto out;
|
2017-07-20 02:37:22 +09:00
|
|
|
#endif
|
2018-03-03 23:29:02 +09:00
|
|
|
ret = efi_watchdog_register();
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
goto out;
|
2017-07-20 02:37:22 +09:00
|
|
|
|
|
|
|
/* Initialize EFI runtime services */
|
2018-03-03 23:29:02 +09:00
|
|
|
ret = efi_reset_system_init();
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
goto out;
|
|
|
|
ret = efi_get_time_init();
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
out:
|
|
|
|
efi_obj_list_initialized = ret;
|
|
|
|
return ret;
|
2017-07-20 02:37:22 +09:00
|
|
|
}
|
|
|
|
|
2018-04-04 04:59:32 +09:00
|
|
|
/*
|
|
|
|
* Allow unaligned memory access.
|
|
|
|
*
|
|
|
|
* This routine is overridden by architectures providing this feature.
|
|
|
|
*/
|
|
|
|
void __weak allow_unaligned(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-10-19 01:13:13 +09:00
|
|
|
/*
|
|
|
|
* Set the load options of an image from an environment variable.
|
|
|
|
*
|
|
|
|
* @loaded_image_info: the image
|
|
|
|
* @env_var: name of the environment variable
|
|
|
|
*/
|
|
|
|
static void set_load_options(struct efi_loaded_image *loaded_image_info,
|
|
|
|
const char *env_var)
|
|
|
|
{
|
|
|
|
size_t size;
|
|
|
|
const char *env = env_get(env_var);
|
|
|
|
|
|
|
|
loaded_image_info->load_options = NULL;
|
|
|
|
loaded_image_info->load_options_size = 0;
|
|
|
|
if (!env)
|
|
|
|
return;
|
|
|
|
size = strlen(env) + 1;
|
|
|
|
loaded_image_info->load_options = calloc(size, sizeof(u16));
|
|
|
|
if (!loaded_image_info->load_options) {
|
|
|
|
printf("ERROR: Out of memory\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
utf8_to_utf16(loaded_image_info->load_options, (u8 *)env, size);
|
|
|
|
loaded_image_info->load_options_size = size * 2;
|
|
|
|
}
|
|
|
|
|
2016-04-11 23:55:26 +09:00
|
|
|
static void *copy_fdt(void *fdt)
|
|
|
|
{
|
|
|
|
u64 fdt_size = fdt_totalsize(fdt);
|
2016-04-12 06:51:01 +09:00
|
|
|
unsigned long fdt_ram_start = -1L, fdt_pages;
|
|
|
|
u64 new_fdt_addr;
|
2016-04-11 23:55:26 +09:00
|
|
|
void *new_fdt;
|
2016-04-12 06:51:01 +09:00
|
|
|
int i;
|
2016-04-11 23:55:26 +09:00
|
|
|
|
2016-04-12 06:51:01 +09:00
|
|
|
for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
|
|
|
|
u64 ram_start = gd->bd->bi_dram[i].start;
|
|
|
|
u64 ram_size = gd->bd->bi_dram[i].size;
|
2016-04-11 23:55:26 +09:00
|
|
|
|
2016-04-12 06:51:01 +09:00
|
|
|
if (!ram_size)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ram_start < fdt_ram_start)
|
|
|
|
fdt_ram_start = ram_start;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Give us at least 4kb breathing room */
|
2017-08-12 04:19:25 +09:00
|
|
|
fdt_size = ALIGN(fdt_size + 4096, EFI_PAGE_SIZE);
|
2016-04-12 06:51:01 +09:00
|
|
|
fdt_pages = fdt_size >> EFI_PAGE_SHIFT;
|
|
|
|
|
|
|
|
/* Safe fdt location is at 128MB */
|
|
|
|
new_fdt_addr = fdt_ram_start + (128 * 1024 * 1024) + fdt_size;
|
2018-01-19 07:21:22 +09:00
|
|
|
if (efi_allocate_pages(1, EFI_RUNTIME_SERVICES_DATA, fdt_pages,
|
2016-04-12 06:51:01 +09:00
|
|
|
&new_fdt_addr) != EFI_SUCCESS) {
|
|
|
|
/* If we can't put it there, put it somewhere */
|
2017-08-12 04:19:25 +09:00
|
|
|
new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size);
|
2018-01-19 07:21:22 +09:00
|
|
|
if (efi_allocate_pages(1, EFI_RUNTIME_SERVICES_DATA, fdt_pages,
|
2017-07-03 20:32:35 +09:00
|
|
|
&new_fdt_addr) != EFI_SUCCESS) {
|
|
|
|
printf("ERROR: Failed to reserve space for FDT\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-04-12 06:51:01 +09:00
|
|
|
}
|
2017-07-03 20:32:35 +09:00
|
|
|
|
2016-04-12 06:51:01 +09:00
|
|
|
new_fdt = (void*)(ulong)new_fdt_addr;
|
2016-04-11 23:55:26 +09:00
|
|
|
memcpy(new_fdt, fdt, fdt_totalsize(fdt));
|
|
|
|
fdt_set_totalsize(new_fdt, fdt_size);
|
|
|
|
|
|
|
|
return new_fdt;
|
|
|
|
}
|
|
|
|
|
2017-10-19 01:13:08 +09:00
|
|
|
static efi_status_t efi_do_enter(
|
2018-01-11 16:16:09 +09:00
|
|
|
efi_handle_t image_handle, struct efi_system_table *st,
|
2018-01-24 08:18:08 +09:00
|
|
|
EFIAPI efi_status_t (*entry)(
|
|
|
|
efi_handle_t image_handle,
|
|
|
|
struct efi_system_table *st))
|
2017-07-05 06:15:21 +09:00
|
|
|
{
|
|
|
|
efi_status_t ret = EFI_LOAD_ERROR;
|
|
|
|
|
|
|
|
if (entry)
|
|
|
|
ret = entry(image_handle, st);
|
|
|
|
st->boottime->exit(image_handle, ret, 0, NULL);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-11-10 11:49:03 +09:00
|
|
|
#ifdef CONFIG_ARM64
|
2018-01-24 08:18:08 +09:00
|
|
|
static efi_status_t efi_run_in_el2(EFIAPI efi_status_t (*entry)(
|
2018-01-11 16:16:09 +09:00
|
|
|
efi_handle_t image_handle, struct efi_system_table *st),
|
|
|
|
efi_handle_t image_handle, struct efi_system_table *st)
|
2016-11-10 11:49:03 +09:00
|
|
|
{
|
|
|
|
/* Enable caches again */
|
|
|
|
dcache_enable();
|
|
|
|
|
2017-07-05 06:15:21 +09:00
|
|
|
return efi_do_enter(image_handle, st, entry);
|
2016-11-10 11:49:03 +09:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-04-06 16:40:51 +09:00
|
|
|
/* Carve out DT reserved memory ranges */
|
|
|
|
static efi_status_t efi_carve_out_dt_rsv(void *fdt)
|
|
|
|
{
|
|
|
|
int nr_rsv, i;
|
|
|
|
uint64_t addr, size, pages;
|
|
|
|
|
|
|
|
nr_rsv = fdt_num_mem_rsv(fdt);
|
|
|
|
|
|
|
|
/* Look for an existing entry and add it to the efi mem map. */
|
|
|
|
for (i = 0; i < nr_rsv; i++) {
|
|
|
|
if (fdt_get_mem_rsv(fdt, i, &addr, &size) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
pages = ALIGN(size, EFI_PAGE_SIZE) >> EFI_PAGE_SHIFT;
|
|
|
|
efi_add_memory_map(addr, pages, EFI_RESERVED_MEMORY_TYPE,
|
|
|
|
false);
|
|
|
|
}
|
|
|
|
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2018-03-03 23:29:03 +09:00
|
|
|
static efi_status_t efi_install_fdt(void *fdt)
|
|
|
|
{
|
|
|
|
bootm_headers_t img = { 0 };
|
|
|
|
ulong fdt_pages, fdt_size, fdt_start, fdt_end;
|
|
|
|
efi_status_t ret;
|
|
|
|
|
|
|
|
if (fdt_check_header(fdt)) {
|
|
|
|
printf("ERROR: invalid device tree\n");
|
|
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Prepare fdt for payload */
|
|
|
|
fdt = copy_fdt(fdt);
|
|
|
|
if (!fdt)
|
|
|
|
return EFI_OUT_OF_RESOURCES;
|
|
|
|
|
|
|
|
if (image_setup_libfdt(&img, fdt, 0, NULL)) {
|
|
|
|
printf("ERROR: failed to process device tree\n");
|
|
|
|
return EFI_LOAD_ERROR;
|
|
|
|
}
|
|
|
|
|
2018-04-06 16:40:51 +09:00
|
|
|
if (efi_carve_out_dt_rsv(fdt) != EFI_SUCCESS) {
|
|
|
|
printf("ERROR: failed to carve out memory\n");
|
|
|
|
return EFI_LOAD_ERROR;
|
|
|
|
}
|
|
|
|
|
2018-03-03 23:29:03 +09:00
|
|
|
/* Link to it in the efi tables */
|
|
|
|
ret = efi_install_configuration_table(&efi_guid_fdt, fdt);
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
return EFI_OUT_OF_RESOURCES;
|
|
|
|
|
|
|
|
/* And reserve the space in the memory map */
|
|
|
|
fdt_start = ((ulong)fdt) & ~EFI_PAGE_MASK;
|
|
|
|
fdt_end = ((ulong)fdt) + fdt_totalsize(fdt);
|
|
|
|
fdt_size = (fdt_end - fdt_start) + EFI_PAGE_MASK;
|
|
|
|
fdt_pages = fdt_size >> EFI_PAGE_SHIFT;
|
|
|
|
/* Give a bootloader the chance to modify the device tree */
|
|
|
|
fdt_pages += 2;
|
|
|
|
ret = efi_add_memory_map(fdt_start, fdt_pages,
|
|
|
|
EFI_BOOT_SERVICES_DATA, true);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-03-10 08:27:20 +09:00
|
|
|
/*
|
|
|
|
* Load an EFI payload into a newly allocated piece of memory, register all
|
|
|
|
* EFI objects it would want to access and jump to it.
|
|
|
|
*/
|
2018-03-03 23:29:03 +09:00
|
|
|
static efi_status_t do_bootefi_exec(void *efi,
|
2017-10-19 01:13:08 +09:00
|
|
|
struct efi_device_path *device_path,
|
|
|
|
struct efi_device_path *image_path)
|
2016-03-10 08:27:20 +09:00
|
|
|
{
|
2017-09-14 07:05:33 +09:00
|
|
|
struct efi_loaded_image loaded_image_info = {};
|
|
|
|
struct efi_object loaded_image_info_obj = {};
|
2017-10-10 21:23:06 +09:00
|
|
|
struct efi_device_path *memdp = NULL;
|
2018-03-03 23:29:01 +09:00
|
|
|
efi_status_t ret;
|
2017-09-14 07:05:33 +09:00
|
|
|
|
2018-01-24 08:18:08 +09:00
|
|
|
EFIAPI efi_status_t (*entry)(efi_handle_t image_handle,
|
|
|
|
struct efi_system_table *st);
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2017-10-10 21:23:06 +09:00
|
|
|
/*
|
|
|
|
* Special case for efi payload not loaded from disk, such as
|
|
|
|
* 'bootefi hello' or for example payload loaded directly into
|
|
|
|
* memory via jtag/etc:
|
|
|
|
*/
|
|
|
|
if (!device_path && !image_path) {
|
|
|
|
printf("WARNING: using memory device/image path, this may confuse some payloads!\n");
|
|
|
|
/* actual addresses filled in after efi_load_pe() */
|
|
|
|
memdp = efi_dp_from_mem(0, 0, 0);
|
|
|
|
device_path = image_path = memdp;
|
|
|
|
} else {
|
|
|
|
assert(device_path && image_path);
|
|
|
|
}
|
|
|
|
|
2017-09-14 07:05:33 +09:00
|
|
|
efi_setup_loaded_image(&loaded_image_info, &loaded_image_info_obj,
|
|
|
|
device_path, image_path);
|
|
|
|
|
2016-03-10 08:27:20 +09:00
|
|
|
/*
|
|
|
|
* gd lives in a fixed register which may get clobbered while we execute
|
|
|
|
* the payload. So save it here and restore it on every callback entry
|
|
|
|
*/
|
|
|
|
efi_save_gd();
|
|
|
|
|
2017-10-19 01:13:15 +09:00
|
|
|
/* Transfer environment variable bootargs as load options */
|
|
|
|
set_load_options(&loaded_image_info, "bootargs");
|
2016-03-10 08:27:20 +09:00
|
|
|
/* Load the EFI payload */
|
|
|
|
entry = efi_load_pe(efi, &loaded_image_info);
|
2017-09-14 07:05:33 +09:00
|
|
|
if (!entry) {
|
2018-03-03 23:29:01 +09:00
|
|
|
ret = EFI_LOAD_ERROR;
|
2017-09-14 07:05:33 +09:00
|
|
|
goto exit;
|
|
|
|
}
|
2016-08-17 04:08:45 +09:00
|
|
|
|
2017-10-10 21:23:06 +09:00
|
|
|
if (memdp) {
|
|
|
|
struct efi_device_path_memory *mdp = (void *)memdp;
|
|
|
|
mdp->memory_type = loaded_image_info.image_code_type;
|
|
|
|
mdp->start_address = (uintptr_t)loaded_image_info.image_base;
|
|
|
|
mdp->end_address = mdp->start_address +
|
|
|
|
loaded_image_info.image_size;
|
|
|
|
}
|
|
|
|
|
efi_loader: efi variable support
Add EFI variable support, mapping to u-boot environment variables.
Variables are pretty important for setting up boot order, among other
things. If the board supports saveenv, then it will be called in
ExitBootServices() to persist variables set by the efi payload. (For
example, fallback.efi configuring BootOrder and BootXXXX load-option
variables.)
Variables are *not* currently exposed at runtime, post ExitBootServices.
On boards without a dedicated device for storage, which the loaded OS
is not trying to also use, this is rather tricky. One idea, at least
for boards that can persist RAM across reboot, is to keep a "journal"
of modified variables in RAM, and then turn halt into a reboot into
u-boot, plus store variables, plus halt. Whatever the solution, it
likely involves some per-board support.
Mapping between EFI variables and u-boot variables:
efi_$guid_$varname = {attributes}(type)value
For example:
efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported=
"{ro,boot,run}(blob)0000000000000000"
efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_BootOrder=
"(blob)00010000"
The attributes are a comma separated list of these possible
attributes:
+ ro - read-only
+ boot - boot-services access
+ run - runtime access
NOTE: with current implementation, no variables are available after
ExitBootServices, and all are persisted (if possible).
If not specified, the attributes default to "{boot}".
The required type is one of:
+ utf8 - raw utf8 string
+ blob - arbitrary length hex string
Signed-off-by: Rob Clark <robdclark@gmail.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
2017-09-14 07:05:37 +09:00
|
|
|
/* we don't support much: */
|
|
|
|
env_set("efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported",
|
|
|
|
"{ro,boot}(blob)0000000000000000");
|
|
|
|
|
2016-03-10 08:27:20 +09:00
|
|
|
/* Call our payload! */
|
2016-06-02 18:38:27 +09:00
|
|
|
debug("%s:%d Jumping to 0x%lx\n", __func__, __LINE__, (long)entry);
|
2016-05-21 06:28:23 +09:00
|
|
|
|
|
|
|
if (setjmp(&loaded_image_info.exit_jmp)) {
|
2017-09-14 07:05:33 +09:00
|
|
|
ret = loaded_image_info.exit_status;
|
|
|
|
goto exit;
|
2016-05-21 06:28:23 +09:00
|
|
|
}
|
|
|
|
|
2016-11-17 09:02:58 +09:00
|
|
|
#ifdef CONFIG_ARM64
|
|
|
|
/* On AArch64 we need to make sure we call our payload in < EL3 */
|
|
|
|
if (current_el() == 3) {
|
|
|
|
smp_kick_all_cpus();
|
|
|
|
dcache_disable(); /* flush cache before switch to EL2 */
|
2016-11-10 11:49:03 +09:00
|
|
|
|
|
|
|
/* Move into EL2 and keep running there */
|
2017-11-26 22:05:22 +09:00
|
|
|
armv8_switch_to_el2((ulong)entry,
|
|
|
|
(ulong)&loaded_image_info_obj.handle,
|
2017-01-17 10:39:17 +09:00
|
|
|
(ulong)&systab, 0, (ulong)efi_run_in_el2,
|
2016-11-10 11:49:03 +09:00
|
|
|
ES_TO_AARCH64);
|
|
|
|
|
|
|
|
/* Should never reach here, efi exits with longjmp */
|
|
|
|
while (1) { }
|
2016-11-17 09:02:58 +09:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-11-26 22:05:22 +09:00
|
|
|
ret = efi_do_enter(loaded_image_info_obj.handle, &systab, entry);
|
2017-09-14 07:05:33 +09:00
|
|
|
|
|
|
|
exit:
|
|
|
|
/* image has returned, loaded-image obj goes *poof*: */
|
|
|
|
list_del(&loaded_image_info_obj.link);
|
|
|
|
|
|
|
|
return ret;
|
2016-03-10 08:27:20 +09:00
|
|
|
}
|
|
|
|
|
2018-03-03 23:29:03 +09:00
|
|
|
static int do_bootefi_bootmgr_exec(void)
|
2017-09-14 07:05:38 +09:00
|
|
|
{
|
|
|
|
struct efi_device_path *device_path, *file_path;
|
|
|
|
void *addr;
|
|
|
|
efi_status_t r;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* gd lives in a fixed register which may get clobbered while we execute
|
|
|
|
* the payload. So save it here and restore it on every callback entry
|
|
|
|
*/
|
|
|
|
efi_save_gd();
|
|
|
|
|
|
|
|
addr = efi_bootmgr_load(&device_path, &file_path);
|
|
|
|
if (!addr)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
printf("## Starting EFI application at %p ...\n", addr);
|
2018-03-03 23:29:03 +09:00
|
|
|
r = do_bootefi_exec(addr, device_path, file_path);
|
2017-09-14 07:05:38 +09:00
|
|
|
printf("## Application terminated, r = %lu\n",
|
|
|
|
r & ~EFI_ERROR_MASK);
|
|
|
|
|
|
|
|
if (r != EFI_SUCCESS)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-03-10 08:27:20 +09:00
|
|
|
/* Interpreter command to boot an arbitrary EFI image from memory */
|
|
|
|
static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
|
|
{
|
2018-03-03 23:29:03 +09:00
|
|
|
unsigned long addr;
|
|
|
|
char *saddr;
|
2017-10-19 01:13:08 +09:00
|
|
|
efi_status_t r;
|
2018-03-03 23:29:03 +09:00
|
|
|
void *fdt_addr;
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2018-04-04 04:59:32 +09:00
|
|
|
/* Allow unaligned memory access */
|
|
|
|
allow_unaligned();
|
|
|
|
|
2018-03-03 23:29:02 +09:00
|
|
|
/* Initialize EFI drivers */
|
|
|
|
r = efi_init_obj_list();
|
|
|
|
if (r != EFI_SUCCESS) {
|
|
|
|
printf("Error: Cannot set up EFI drivers, r = %lu\n",
|
|
|
|
r & ~EFI_ERROR_MASK);
|
|
|
|
return CMD_RET_FAILURE;
|
|
|
|
}
|
|
|
|
|
2016-03-10 08:27:20 +09:00
|
|
|
if (argc < 2)
|
2016-08-13 20:02:06 +09:00
|
|
|
return CMD_RET_USAGE;
|
2018-03-03 23:29:03 +09:00
|
|
|
|
|
|
|
if (argc > 2) {
|
|
|
|
fdt_addr = (void *)simple_strtoul(argv[2], NULL, 16);
|
|
|
|
if (!fdt_addr && *argv[2] != '0')
|
|
|
|
return CMD_RET_USAGE;
|
|
|
|
/* Install device tree */
|
|
|
|
r = efi_install_fdt(fdt_addr);
|
|
|
|
if (r != EFI_SUCCESS) {
|
|
|
|
printf("ERROR: failed to install device tree\n");
|
|
|
|
return CMD_RET_FAILURE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Remove device tree. EFI_NOT_FOUND can be ignored here */
|
|
|
|
efi_install_configuration_table(&efi_guid_fdt, NULL);
|
|
|
|
printf("WARNING: booting without device tree\n");
|
|
|
|
}
|
2016-11-08 00:47:08 +09:00
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_HELLO
|
|
|
|
if (!strcmp(argv[1], "hello")) {
|
2017-09-05 10:19:37 +09:00
|
|
|
ulong size = __efi_helloworld_end - __efi_helloworld_begin;
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2017-08-29 01:54:30 +09:00
|
|
|
saddr = env_get("loadaddr");
|
|
|
|
if (saddr)
|
|
|
|
addr = simple_strtoul(saddr, NULL, 16);
|
|
|
|
else
|
|
|
|
addr = CONFIG_SYS_LOAD_ADDR;
|
2017-09-05 10:19:37 +09:00
|
|
|
memcpy((char *)addr, __efi_helloworld_begin, size);
|
2016-11-08 00:47:08 +09:00
|
|
|
} else
|
2017-09-15 17:06:11 +09:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
|
|
|
|
if (!strcmp(argv[1], "selftest")) {
|
2017-09-21 05:54:58 +09:00
|
|
|
struct efi_loaded_image loaded_image_info = {};
|
|
|
|
struct efi_object loaded_image_info_obj = {};
|
|
|
|
|
2017-10-19 01:13:09 +09:00
|
|
|
/* Construct a dummy device path. */
|
|
|
|
bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE,
|
|
|
|
(uintptr_t)&efi_selftest,
|
|
|
|
(uintptr_t)&efi_selftest);
|
|
|
|
bootefi_image_path = efi_dp_from_file(NULL, 0, "\\selftest");
|
|
|
|
|
2017-09-21 05:54:58 +09:00
|
|
|
efi_setup_loaded_image(&loaded_image_info,
|
|
|
|
&loaded_image_info_obj,
|
|
|
|
bootefi_device_path, bootefi_image_path);
|
2017-09-15 17:06:11 +09:00
|
|
|
/*
|
|
|
|
* gd lives in a fixed register which may get clobbered while we
|
|
|
|
* execute the payload. So save it here and restore it on every
|
|
|
|
* callback entry
|
|
|
|
*/
|
|
|
|
efi_save_gd();
|
2017-10-19 01:13:13 +09:00
|
|
|
/* Transfer environment variable efi_selftest as load options */
|
|
|
|
set_load_options(&loaded_image_info, "efi_selftest");
|
|
|
|
/* Execute the test */
|
2017-11-26 22:05:22 +09:00
|
|
|
r = efi_selftest(loaded_image_info_obj.handle, &systab);
|
2017-10-19 01:13:14 +09:00
|
|
|
efi_restore_gd();
|
2017-10-19 01:13:13 +09:00
|
|
|
free(loaded_image_info.load_options);
|
2017-10-19 01:13:14 +09:00
|
|
|
list_del(&loaded_image_info_obj.link);
|
|
|
|
return r != EFI_SUCCESS;
|
2017-09-15 17:06:11 +09:00
|
|
|
} else
|
2016-11-08 00:47:08 +09:00
|
|
|
#endif
|
2017-09-14 07:05:38 +09:00
|
|
|
if (!strcmp(argv[1], "bootmgr")) {
|
2018-03-03 23:29:03 +09:00
|
|
|
return do_bootefi_bootmgr_exec();
|
2017-09-14 07:05:38 +09:00
|
|
|
} else {
|
2016-11-08 00:47:08 +09:00
|
|
|
saddr = argv[1];
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2016-11-08 00:47:08 +09:00
|
|
|
addr = simple_strtoul(saddr, NULL, 16);
|
2018-01-25 04:33:54 +09:00
|
|
|
/* Check that a numeric value was passed */
|
|
|
|
if (!addr && *saddr != '0')
|
|
|
|
return CMD_RET_USAGE;
|
2016-11-08 00:47:08 +09:00
|
|
|
|
2016-04-14 23:07:53 +09:00
|
|
|
}
|
|
|
|
|
2016-11-08 00:47:05 +09:00
|
|
|
printf("## Starting EFI application at %08lx ...\n", addr);
|
2018-03-03 23:29:03 +09:00
|
|
|
r = do_bootefi_exec((void *)addr, bootefi_device_path,
|
|
|
|
bootefi_image_path);
|
2017-07-05 06:15:23 +09:00
|
|
|
printf("## Application terminated, r = %lu\n",
|
|
|
|
r & ~EFI_ERROR_MASK);
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2017-07-05 06:15:23 +09:00
|
|
|
if (r != EFI_SUCCESS)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
2016-03-10 08:27:20 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYS_LONGHELP
|
|
|
|
static char bootefi_help_text[] =
|
2016-04-14 23:07:53 +09:00
|
|
|
"<image address> [fdt address]\n"
|
|
|
|
" - boot EFI payload stored at address <image address>.\n"
|
|
|
|
" If specified, the device tree located at <fdt address> gets\n"
|
2016-11-08 00:47:08 +09:00
|
|
|
" exposed as EFI configuration table.\n"
|
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_HELLO
|
2017-09-15 17:06:11 +09:00
|
|
|
"bootefi hello\n"
|
|
|
|
" - boot a sample Hello World application stored within U-Boot\n"
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
|
2018-03-03 23:29:03 +09:00
|
|
|
"bootefi selftest [fdt address]\n"
|
2017-09-15 17:06:11 +09:00
|
|
|
" - boot an EFI selftest application stored within U-Boot\n"
|
2017-10-19 01:13:13 +09:00
|
|
|
" Use environment variable efi_selftest to select a single test.\n"
|
|
|
|
" Use 'setenv efi_selftest list' to enumerate all tests.\n"
|
2016-11-08 00:47:08 +09:00
|
|
|
#endif
|
2018-01-31 03:47:43 +09:00
|
|
|
"bootefi bootmgr [fdt addr]\n"
|
2017-09-14 07:05:38 +09:00
|
|
|
" - load and boot EFI payload based on BootOrder/BootXXXX variables.\n"
|
|
|
|
"\n"
|
|
|
|
" If specified, the device tree located at <fdt address> gets\n"
|
|
|
|
" exposed as EFI configuration table.\n";
|
2016-03-10 08:27:20 +09:00
|
|
|
#endif
|
|
|
|
|
|
|
|
U_BOOT_CMD(
|
2016-04-14 23:07:53 +09:00
|
|
|
bootefi, 3, 0, do_bootefi,
|
2016-06-08 03:14:31 +09:00
|
|
|
"Boots an EFI payload from memory",
|
2016-03-10 08:27:20 +09:00
|
|
|
bootefi_help_text
|
|
|
|
);
|
2016-03-04 09:10:14 +09:00
|
|
|
|
2017-09-14 07:05:33 +09:00
|
|
|
void efi_set_bootdev(const char *dev, const char *devnr, const char *path)
|
|
|
|
{
|
|
|
|
char filename[32] = { 0 }; /* dp->str is u16[32] long */
|
|
|
|
char *s;
|
2016-08-05 21:49:53 +09:00
|
|
|
|
2017-09-14 07:05:33 +09:00
|
|
|
if (strcmp(dev, "Net")) {
|
|
|
|
struct blk_desc *desc;
|
2018-04-04 05:40:55 +09:00
|
|
|
disk_partition_t fs_partition;
|
2017-09-14 07:05:33 +09:00
|
|
|
int part;
|
2016-04-11 23:16:18 +09:00
|
|
|
|
2018-04-04 05:40:55 +09:00
|
|
|
part = blk_get_device_part_str(dev, devnr, &desc, &fs_partition,
|
|
|
|
1);
|
|
|
|
if (part < 0)
|
2017-11-17 16:47:09 +09:00
|
|
|
return;
|
2016-03-04 09:10:14 +09:00
|
|
|
|
2017-09-14 07:05:33 +09:00
|
|
|
bootefi_device_path = efi_dp_from_part(desc, part);
|
|
|
|
} else {
|
2018-04-14 05:26:39 +09:00
|
|
|
#ifdef CONFIG_NET
|
2017-09-14 07:05:33 +09:00
|
|
|
bootefi_device_path = efi_dp_from_eth();
|
|
|
|
#endif
|
|
|
|
}
|
2016-04-11 23:16:19 +09:00
|
|
|
|
2017-09-14 07:05:38 +09:00
|
|
|
if (!path)
|
|
|
|
return;
|
|
|
|
|
2016-07-21 08:44:46 +09:00
|
|
|
if (strcmp(dev, "Net")) {
|
|
|
|
/* Add leading / to fs paths, because they're absolute */
|
2017-09-14 07:05:33 +09:00
|
|
|
snprintf(filename, sizeof(filename), "/%s", path);
|
2016-07-21 08:44:46 +09:00
|
|
|
} else {
|
2017-09-14 07:05:33 +09:00
|
|
|
snprintf(filename, sizeof(filename), "%s", path);
|
2016-07-21 08:44:46 +09:00
|
|
|
}
|
2017-07-24 20:59:09 +09:00
|
|
|
/* DOS style file path: */
|
2017-09-14 07:05:33 +09:00
|
|
|
s = filename;
|
2017-07-24 20:59:09 +09:00
|
|
|
while ((s = strchr(s, '/')))
|
|
|
|
*s++ = '\\';
|
2017-09-14 07:05:33 +09:00
|
|
|
bootefi_image_path = efi_dp_from_file(NULL, 0, filename);
|
2016-03-04 09:10:14 +09:00
|
|
|
}
|