smallsolar/u-boot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

efi: Rename the lib/efi directory

Browse Source 
This directory was created when U-Boot gained the ability to run as an
EFI app in 2015. Since then the EFI-loader feature has been added.

The code in lib/efi is not actually used by the loader, so the name is
confusing.

Rename the directory to efi_client to indicate that it includes files
just for U-Boot being a client of EFI, i.e. the EFI app and stub.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass
2025-05-23 14:06:39 +01:00
parent fe719aa8e8
commit 5f4327ec9f
16 changed files with 9 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
lib/efi/Kconfig
View File

@@ -1,82 +0,0 @@
menu "U-Boot as UEFI application"
depends on X86 || ARM
config EFI
bool "Support running U-Boot from EFI"
depends on X86 || ARM
imply X86_TSC_READ_BASE
help
U-Boot can be started from EFI on certain platforms. This allows
EFI to perform most of the system init and then jump to U-Boot for
final system boot. Another option is to run U-Boot as an EFI
application, with U-Boot using EFI's drivers instead of its own.
choice
prompt "Select EFI mode to use"
depends on EFI
config EFI_APP
bool "Support running as an EFI application"
depends on X86 || ARM
select CHARSET
help
Build U-Boot as an application which can be started from EFI. This
is useful for examining a platform in the early stages of porting
U-Boot to it. It allows only very basic functionality, such as a
command prompt and memory and I/O functions. Use 'reset' to return
to EFI.
config EFI_STUB
select POSITION_INDEPENDENT if ARM
bool "Support running as an EFI payload"
endchoice
choice
prompt "EFI app 32/64-bit selection"
depends on EFI_APP
help
EFI does not support mixing 32-bit and 64-bit modes. This is a
significant problem because it means that you must build a stub with
the correct type for EFI to load it correctly. If you are using
32-bit EFI, select 32-bit here, else select 64-bit. Failure to do
this may produce no error message - it just won't start!
config EFI_APP_32BIT
bool "Produce an app for running with 32-bit EFI"
config EFI_APP_64BIT
bool "Produce an app for running with 64-bit EFI"
endchoice
choice
prompt "EFI stub 32/64-bit selection"
depends on EFI_STUB
help
EFI does not support mixing 32-bit and 64-bit modes. This is a
significant problem because it means that you must build a stub with
the correct type for EFI to load it correctly. If you are using
32-bit EFI, select 32-bit here, else select 64-bit. Failure to do
this may produce no error message - it just won't start!
config EFI_STUB_32BIT
depends on !ARM
bool "Produce a stub for running with 32-bit EFI"
config EFI_STUB_64BIT
bool "Produce a stub for running with 64-bit EFI"
endchoice
config EFI_RAM_SIZE
hex "Amount of EFI RAM for U-Boot"
depends on EFI_APP
default 0x10000000
help
Set the amount of EFI RAM which is claimed by U-Boot for its own
use. U-Boot allocates this from EFI on start-up (along with a few
other smaller amounts) and it can never be increased after that.
It is used as the RAM size in with U-Boot.
endmenu

28
lib/efi/Makefile
View File

@@ -1,28 +0,0 @@
# SPDX-License-Identifier: GPL-2.0+
#
# (C) Copyright 2015 Google, Inc
obj-$(CONFIG_EFI_APP) += efi_app.o efi.o efi_app_init.o efi_vars.o efi_dtb.o
obj-$(CONFIG_EFI_APP) += sdram.o
obj-$(CONFIG_EFI_STUB) += efi_info.o
ifeq ($(CONFIG_ARM64),y)
efi_stub.o := efi_stub_arm64.o
else
efi_stub.o := efi_stub_x86.o
ifeq ($(CONFIG_EFI_STUB_64BIT),y) # && !CONFIG_ARM64
CFLAGS_REMOVE_$(efi_stub.o) := -march=i386 -m32
CFLAGS_$(efi_stub.o) := -m64
CFLAGS_REMOVE_efi.o := -march=i386 -m32
CFLAGS_efi.o := -fpic -m64
endif
endif
CFLAGS_REMOVE_$(efi_stub.o) += -mregparm=3
CFLAGS_$(efi_stub.o) += -fpic -fshort-wchar
CFLAGS_REMOVE_efi.o += -mregparm=3
CFLAGS_efi.o += -fpic -fshort-wchar
$(info removing flags $(CFLAGS_REMOVE_$(efi_stub.o)))
extra-$(CONFIG_EFI_STUB) += $(efi_stub.o) efi.o

209
lib/efi/efi.c
View File

@@ -1,209 +0,0 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Functions shared by the app and stub
*
* Copyright (c) 2015 Google, Inc
*
* EFI information obtained here:
* http://wiki.phoenix.com/wiki/index.php/EFI_BOOT_SERVICES
*
* Common EFI functions
*/
#include <debug_uart.h>
#include <errno.h>
#include <malloc.h>
#include <linux/err.h>
#include <linux/types.h>
#include <efi.h>
#include <efi_api.h>
static struct efi_priv *global_priv;
struct efi_priv *efi_get_priv(void)
{
return global_priv;
}
void efi_set_priv(struct efi_priv *priv)
{
global_priv = priv;
}
struct efi_system_table *efi_get_sys_table(void)
{
return global_priv->sys_table;
}
struct efi_boot_services *efi_get_boot(void)
{
return global_priv->boot;
}
unsigned long efi_get_ram_base(void)
{
return global_priv->ram_base;
}
/*
* Global declaration of gd.
*
* As we write to it before relocation we have to make sure it is not put into
* a .bss section which may overlap a .rela section. Initialization forces it
* into a .data section which cannot overlap any .rela section.
*/
struct global_data *global_data_ptr = (struct global_data *)~0;
/*
* Unfortunately we cannot access any code outside what is built especially
* for the stub. lib/string.c is already being built for the U-Boot payload
* so it uses the wrong compiler flags. Add our own memset() here.
*/
static void efi_memset(void *ptr, int ch, int size)
{
char *dest = ptr;
while (size-- > 0)
*dest++ = ch;
}
/*
* Since the EFI stub cannot access most of the U-Boot code, add our own
* simple console output functions here. The EFI app will not use these since
* it can use the normal console.
*/
void efi_putc(struct efi_priv *priv, const char ch)
{
struct efi_simple_text_output_protocol *con = priv->sys_table->con_out;
uint16_t ucode[2];
ucode[0] = ch;
ucode[1] = '\0';
con->output_string(con, ucode);
}
void efi_puts(struct efi_priv *priv, const char *str)
{
while (*str)
efi_putc(priv, *str++);
}
int efi_init(struct efi_priv *priv, const char *banner, efi_handle_t image,
struct efi_system_table *sys_table)
{
efi_guid_t loaded_image_guid = EFI_LOADED_IMAGE_PROTOCOL_GUID;
struct efi_boot_services *boot = sys_table->boottime;
struct efi_loaded_image *loaded_image;
int ret;
efi_memset(priv, '\0', sizeof(*priv));
priv->sys_table = sys_table;
priv->boot = sys_table->boottime;
priv->parent_image = image;
priv->run = sys_table->runtime;
efi_puts(priv, "U-Boot EFI ");
efi_puts(priv, banner);
efi_putc(priv, ' ');
ret = boot->open_protocol(priv->parent_image, &loaded_image_guid,
(void **)&loaded_image, priv->parent_image,
NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (ret) {
efi_puts(priv, "Failed to get loaded image protocol\n");
return ret;
}
priv->loaded_image = loaded_image;
priv->image_data_type = loaded_image->image_data_type;
return 0;
}
void *efi_malloc(struct efi_priv *priv, int size, efi_status_t *retp)
{
struct efi_boot_services *boot = priv->boot;
void *buf = NULL;
*retp = boot->allocate_pool(priv->image_data_type, size, &buf);
return buf;
}
void efi_free(struct efi_priv *priv, void *ptr)
{
struct efi_boot_services *boot = priv->boot;
boot->free_pool(ptr);
}
int efi_store_memory_map(struct efi_priv *priv)
{
struct efi_boot_services *boot = priv->sys_table->boottime;
efi_uintn_t size, desc_size;
efi_status_t ret;
/* Get the memory map so we can switch off EFI */
size = 0;
ret = boot->get_memory_map(&size, NULL, &priv->memmap_key,
&priv->memmap_desc_size,
&priv->memmap_version);
if (ret != EFI_BUFFER_TOO_SMALL) {
/*
* Note this function avoids using printf() since it is not
* available in the stub
*/
printhex2(EFI_BITS_PER_LONG);
putc(' ');
printhex2(ret);
puts(" No memory map\n");
return ret;
}
/*
* Since doing a malloc() may change the memory map and also we want to
* be able to read the memory map in efi_call_exit_boot_services()
* below, after more changes have happened
*/
priv->memmap_alloc = size + 1024;
priv->memmap_size = priv->memmap_alloc;
priv->memmap_desc = efi_malloc(priv, size, &ret);
if (!priv->memmap_desc) {
printhex2(ret);
puts(" No memory for memory descriptor\n");
return ret;
}
ret = boot->get_memory_map(&priv->memmap_size, priv->memmap_desc,
&priv->memmap_key, &desc_size,
&priv->memmap_version);
if (ret) {
printhex2(ret);
puts(" Can't get memory map\n");
return ret;
}
return 0;
}
int efi_call_exit_boot_services(void)
{
struct efi_priv *priv = efi_get_priv();
const struct efi_boot_services *boot = priv->boot;
efi_uintn_t size;
u32 version;
efi_status_t ret;
size = priv->memmap_alloc;
ret = boot->get_memory_map(&size, priv->memmap_desc,
&priv->memmap_key,
&priv->memmap_desc_size, &version);
if (ret) {
printhex2(ret);
puts(" Can't get memory map\n");
return ret;
}
ret = boot->exit_boot_services(priv->parent_image, priv->memmap_key);
if (ret)
return ret;
return 0;
}

280
lib/efi/efi_app.c
View File

@@ -1,280 +0,0 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2015 Google, Inc
*
* EFI information obtained here:
* http://wiki.phoenix.com/wiki/index.php/EFI_BOOT_SERVICES
*
* This file implements U-Boot running as an EFI application.
*/
#include <cpu_func.h>
#include <debug_uart.h>
#include <dm.h>
#include <efi.h>
#include <efi_api.h>
#include <efi_stub.h>
#include <errno.h>
#include <image.h>
#include <init.h>
#include <malloc.h>
#include <sysreset.h>
#include <u-boot/uuid.h>
#include <asm/global_data.h>
#include <linux/err.h>
#include <linux/types.h>
#include <asm/global_data.h>
#include <dm/device-internal.h>
#include <dm/lists.h>
#include <dm/root.h>
#include <mapmem.h>
DECLARE_GLOBAL_DATA_PTR;
int efi_init_obj_list(void)
{
return EFI_SUCCESS;
}
int efi_info_get(enum efi_entry_t type, void **datap, int *sizep)
{
return -ENOSYS;
}
int efi_get_mmap(struct efi_mem_desc **descp, int *sizep, uint *keyp,
int *desc_sizep, uint *versionp)
{
struct efi_priv *priv = efi_get_priv();
struct efi_boot_services *boot = priv->sys_table->boottime;
efi_uintn_t size, desc_size, key;
struct efi_mem_desc *desc;
efi_status_t ret;
u32 version;
/* Get the memory map so we can switch off EFI */
size = 0;
ret = boot->get_memory_map(&size, NULL, &key, &desc_size, &version);
if (ret != EFI_BUFFER_TOO_SMALL)
return log_msg_ret("get", -ENOMEM);
desc = malloc(size);
if (!desc)
return log_msg_ret("mem", -ENOMEM);
ret = boot->get_memory_map(&size, desc, &key, &desc_size, &version);
if (ret)
return log_msg_ret("get", -EINVAL);
*descp = desc;
*sizep = size;
*desc_sizep = desc_size;
*versionp = version;
*keyp = key;
return 0;
}
static efi_status_t setup_memory(struct efi_priv *priv)
{
struct efi_boot_services *boot = priv->boot;
struct global_data *ptr;
efi_physical_addr_t addr;
efi_status_t ret;
int pages;
/*
* Use global_data_ptr instead of gd since it is an assignment. There
* are very few assignments to global_data in U-Boot and this makes
* it easier to find them.
*/
ptr = efi_malloc(priv, sizeof(*ptr), &ret);
if (!ptr)
return ret;
memset(ptr, '\0', sizeof(*ptr));
set_gd(ptr);
gd->malloc_base = (ulong)efi_malloc(priv, CONFIG_VAL(SYS_MALLOC_F_LEN),
&ret);
if (!gd->malloc_base)
return ret;
pages = CONFIG_EFI_RAM_SIZE >> 12;
/*
* Don't allocate any memory above 4GB. U-Boot is a 32-bit application
* so we want it to load below 4GB.
*/
addr = 1ULL << 32;
ret = boot->allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
priv->image_data_type, pages, &addr);
if (ret) {
log_info("(using pool %lx) ", ret);
priv->ram_base = (ulong)efi_malloc(priv, CONFIG_EFI_RAM_SIZE,
&ret);
if (!priv->ram_base)
return ret;
priv->use_pool_for_malloc = true;
} else {
log_info("(using allocated RAM address %lx) ", (ulong)addr);
priv->ram_base = addr;
}
gd->ram_size = pages << 12;
return 0;
}
/**
* free_memory() - Free memory used by the U-Boot app
*
* This frees memory allocated in setup_memory(), in preparation for returning
* to UEFI. It also zeroes the global_data pointer.
*
* @priv: Private EFI data
*/
static void free_memory(struct efi_priv *priv)
{
struct efi_boot_services *boot = priv->boot;
if (priv->use_pool_for_malloc)
efi_free(priv, (void *)priv->ram_base);
else
boot->free_pages(priv->ram_base, gd->ram_size >> 12);
efi_free(priv, (void *)gd->malloc_base);
efi_free(priv, (void *)gd);
set_gd((void *)NULL);
}
static void scan_tables(struct efi_system_table *sys_table)
{
efi_guid_t acpi = EFI_ACPI_TABLE_GUID;
uint i;
for (i = 0; i < sys_table->nr_tables; i++) {
struct efi_configuration_table *tab = &sys_table->tables[i];
if (!memcmp(&tab->guid, &acpi, sizeof(efi_guid_t)))
gd_set_acpi_start(map_to_sysmem(tab->table));
}
}
/**
* efi_main() - Start an EFI image
*
* This function is called by our EFI start-up code. It handles running
* U-Boot. If it returns, EFI will continue. Another way to get back to EFI
* is via reset_cpu().
*/
efi_status_t EFIAPI efi_main(efi_handle_t image,
struct efi_system_table *sys_table)
{
struct efi_priv local_priv, *priv = &local_priv;
efi_status_t ret;
/* Set up access to EFI data structures */
ret = efi_init(priv, "App", image, sys_table);
if (ret) {
printf("Failed to set up U-Boot: err=%lx\n", ret);
return ret;
}
efi_set_priv(priv);
/*
* Set up the EFI debug UART so that printf() works. This is
* implemented in the EFI serial driver, serial_efi.c. The application
* can use printf() freely.
*/
debug_uart_init();
ret = setup_memory(priv);
if (ret) {
printf("Failed to set up memory: ret=%lx\n", ret);
return ret;
}
scan_tables(priv->sys_table);
/*
* We could store the EFI memory map here, but it changes all the time,
* so this is only useful for debugging.
*
* ret = efi_store_memory_map(priv);
* if (ret)
* return ret;
*/
printf("starting\n");
board_init_f(GD_FLG_SKIP_RELOC);
board_init_r(NULL, 0);
free_memory(priv);
return EFI_SUCCESS;
}
static void efi_exit(void)
{
struct efi_priv *priv = efi_get_priv();
free_memory(priv);
printf("U-Boot EFI exiting\n");
priv->boot->exit(priv->parent_image, EFI_SUCCESS, 0, NULL);
}
static int efi_sysreset_request(struct udevice *dev, enum sysreset_t type)
{
efi_exit();
return -EINPROGRESS;
}
/*
* Attempt to relocate the kernel to somewhere the firmware isn't using
*/
#define PAGE_SIZE_BITS 12
void board_fixup_os(struct image_info *os)
{
int pages;
ulong load_addr;
u64 addr;
efi_status_t status;
struct efi_priv *priv = efi_get_priv();
struct efi_boot_services *boot = priv->boot;
pages = (os->image_len + ((1 << PAGE_SIZE_BITS) - 1)) >> PAGE_SIZE_BITS;
addr = os->load;
/* Try to allocate at the preferred address */
status = boot->allocate_pages(EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
pages, &addr);
if (status == EFI_SUCCESS)
return;
/* That failed, so try allocating anywhere there's enough room */
status = boot->allocate_pages(EFI_ALLOCATE_ANY_PAGES, EFI_LOADER_DATA, pages, &addr);
if (status == EFI_SUCCESS) {
/* Make sure bootm knows where we loaded the image */
os->load = addr;
return;
}
printf("Failed to alloc %lx bytes at %lx: %lx\n", os->image_len, load_addr,
status);
}
static const struct udevice_id efi_sysreset_ids[] = {
{ .compatible = "efi,reset" },
{ }
};
static struct sysreset_ops efi_sysreset_ops = {
.request = efi_sysreset_request,
};
U_BOOT_DRIVER(efi_sysreset) = {
.name = "efi-sysreset",
.id = UCLASS_SYSRESET,
.of_match = efi_sysreset_ids,
.ops = &efi_sysreset_ops,
};

354
lib/efi/efi_app_init.c
View File

@@ -1,354 +0,0 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* EFI-app board implementation
*
* Copyright 2023 Google LLC
* Written by Simon Glass <sjg@chromium.org>
*/
#include <dm.h>
#include <efi.h>
#include <efi_api.h>
#include <efi_tcg2.h>
#include <errno.h>
#include <malloc.h>
#include <asm/global_data.h>
#include <dm/device-internal.h>
#include <dm/root.h>
#include <linux/types.h>
DECLARE_GLOBAL_DATA_PTR;
static size_t device_path_length(const struct efi_device_path *device_path)
{
const struct efi_device_path *d;
for (d = device_path; d->type != DEVICE_PATH_TYPE_END; d = (void *)d + d->length) {
}
return (void *)d - (void *)device_path + d->length;
}
/**
* efi_bind_block() - bind a new block device to an EFI device
*
* Binds a new top-level EFI_MEDIA device as well as a child block device so
* that the block device can be accessed in U-Boot.
*
* The device can then be accessed using 'part list efi 0', 'fat ls efi 0:1',
* for example, just like any other interface type.
*
* @handle: handle of the controller on which this driver is installed
* @blkio: block io protocol proxied by this driver
* @device_path: EFI device path structure for this
* @len: Length of @device_path in bytes
* @devp: Returns the bound device
* Return: 0 if OK, -ve on error
*/
int efi_bind_block(efi_handle_t handle, struct efi_block_io *blkio,
struct efi_device_path *device_path, int len,
struct udevice **devp)
{
struct efi_media_plat *plat;
struct udevice *dev;
char name[18];
int ret;
size_t device_path_len = device_path_length(device_path);
plat = malloc(sizeof(struct efi_media_plat));
if (!plat)
return log_msg_ret("plat", -ENOMEM);
plat->handle = handle;
plat->blkio = blkio;
plat->device_path = malloc(device_path_len);
if (!plat->device_path)
return log_msg_ret("path", -ENOMEM);
memcpy(plat->device_path, device_path, device_path_len);
ret = device_bind(dm_root(), DM_DRIVER_GET(efi_media), "efi_media",
plat, ofnode_null(), &dev);
if (ret)
return log_msg_ret("bind", ret);
snprintf(name, sizeof(name), "efi_media_%x", dev_seq(dev));
device_set_name(dev, name);
*devp = dev;
return 0;
}
/**
* devpath_is_partition() - Figure out if a device path is a partition
*
* Checks if a device path refers to a partition on some media device. This
* works by checking for a valid partition number in a hard-driver media device
* as the final component of the device path.
*
* @path: device path
* Return: true if a partition, false if not
* (e.g. it might be media which contains partitions)
*/
static bool devpath_is_partition(const struct efi_device_path *path)
{
const struct efi_device_path *p;
bool was_part = false;
for (p = path; p->type != DEVICE_PATH_TYPE_END;
p = (void *)p + p->length) {
was_part = false;
if (p->type == DEVICE_PATH_TYPE_MEDIA_DEVICE &&
p->sub_type == DEVICE_PATH_SUB_TYPE_HARD_DRIVE_PATH) {
struct efi_device_path_hard_drive_path *hd =
(void *)path;
if (hd->partition_number)
was_part = true;
}
}
return was_part;
}
/**
* setup_block() - Find all block devices and setup EFI devices for them
*
* Partitions are ignored, since U-Boot has partition handling. Errors with
* particular devices produce a warning but execution continues to try to
* find others.
*
* Return: 0 if found, -ENOSYS if there is no boot-services table, -ENOTSUPP
* if a required protocol is not supported
*/
static int setup_block(void)
{
efi_guid_t efi_blkio_guid = EFI_BLOCK_IO_PROTOCOL_GUID;
efi_guid_t efi_devpath_guid = EFI_DEVICE_PATH_PROTOCOL_GUID;
efi_guid_t efi_pathutil_guid = EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID;
efi_guid_t efi_pathtext_guid = EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID;
struct efi_boot_services *boot = efi_get_boot();
struct efi_device_path_utilities_protocol *util;
struct efi_device_path_to_text_protocol *text;
struct efi_device_path *path;
struct efi_block_io *blkio;
efi_uintn_t num_handles;
efi_handle_t *handle;
int ret, i;
if (!boot)
return log_msg_ret("sys", -ENOSYS);
/* Find all devices which support the block I/O protocol */
ret = boot->locate_handle_buffer(BY_PROTOCOL, &efi_blkio_guid, NULL,
&num_handles, &handle);
if (ret)
return log_msg_ret("loc", -ENOTSUPP);
log_debug("Found %d handles:\n", (int)num_handles);
/* We need to look up the path size and convert it to text */
ret = boot->locate_protocol(&efi_pathutil_guid, NULL, (void **)&util);
if (ret)
return log_msg_ret("util", -ENOTSUPP);
ret = boot->locate_protocol(&efi_pathtext_guid, NULL, (void **)&text);
if (ret)
return log_msg_ret("text", -ENOTSUPP);
for (i = 0; i < num_handles; i++) {
struct udevice *dev;
const u16 *name;
bool is_part;
int len;
ret = boot->handle_protocol(handle[i], &efi_devpath_guid,
(void **)&path);
if (ret) {
log_warning("- devpath %d failed (ret=%d)\n", i, ret);
continue;
}
ret = boot->handle_protocol(handle[i], &efi_blkio_guid,
(void **)&blkio);
if (ret) {
log_warning("- blkio %d failed (ret=%d)\n", i, ret);
continue;
}
name = text->convert_device_path_to_text(path, true, false);
is_part = devpath_is_partition(path);
if (!is_part) {
len = util->get_device_path_size(path);
ret = efi_bind_block(handle[i], blkio, path, len, &dev);
if (ret) {
log_warning("- blkio bind %d failed (ret=%d)\n",
i, ret);
continue;
}
} else {
dev = NULL;
}
/*
* Show the device name if we created one. Otherwise indicate
* that it is a partition.
*/
printf("%2d: %-12s %ls\n", i, dev ? dev->name : "<partition>",
name);
}
boot->free_pool(handle);
return 0;
}
/**
* setup_net() - Find all network devices and setup EFI devices for them
*
* Return: 0 if found, -ENOSYS if there is no boot-services table, -ENOTSUPP
* if a required protocol is not supported
*/
static int setup_net(void)
{
efi_guid_t efi_snp_guid = EFI_SIMPLE_NETWORK_PROTOCOL_GUID;
struct efi_boot_services *boot = efi_get_boot();
efi_uintn_t num_handles;
efi_handle_t *handle;
int ret, i;
if (!boot)
return log_msg_ret("sys", -ENOSYS);
/* Find all devices which support the simple network protocol */
ret = boot->locate_handle_buffer(BY_PROTOCOL, &efi_snp_guid, NULL,
&num_handles, &handle);
if (ret)
return 0;
log_debug("Found %d net handles:\n", (int)num_handles);
for (i = 0; i < num_handles; i++) {
struct efi_simple_network *snp;
struct efi_net_plat *plat;
struct udevice *dev;
char name[18];
ret = boot->handle_protocol(handle[i], &efi_snp_guid,
(void **)&snp);
if (ret != EFI_SUCCESS) {
log_warning("- snp %d failed (ret=0x%x\n", i, ret);
continue;
}
plat = malloc(sizeof(*plat));
if (!plat) {
log_warning("- snp %d failed to alloc platform data", i);
continue;
}
plat->handle = handle[i];
plat->snp = snp;
ret = device_bind(dm_root(), DM_DRIVER_GET(efi_net), "efi_net",
plat, ofnode_null(), &dev);
if (ret) {
log_warning("- bind snp %d failed (ret=0x%x)\n", i,
ret);
continue;
}
snprintf(name, sizeof(name), "efi_net_%x", dev_seq(dev));
device_set_name(dev, name);
printf("%2d: %-12s\n", i, dev->name);
}
boot->free_pool(handle);
return 0;
}
/**
* setup_tpm() - Find all TPMs and setup EFI devices for them
*
* Return: 0 if found, -ENOSYS if there is no boot-services table, -ENOTSUPP
* if a required protocol is not supported
*/
static int setup_tpm(void)
{
efi_guid_t efi_tcg2_guid = EFI_TCG2_PROTOCOL_GUID;
struct efi_boot_services *boot = efi_get_boot();
efi_uintn_t num_handles;
efi_handle_t *handle;
int ret, i;
if (!boot)
return log_msg_ret("sys", -ENOSYS);
/* Find all devices which support the TCG2 protocol */
ret = boot->locate_handle_buffer(BY_PROTOCOL, &efi_tcg2_guid, NULL,
&num_handles, &handle);
if (ret)
return 0;
log_debug("Found %d TPM handles:\n", (int)num_handles);
for (i = 0; i < num_handles; i++) {
struct efi_tcg2_protocol *proto;
struct efi_tpm_plat *plat;
struct udevice *dev;
char name[18];
ret = boot->handle_protocol(handle[i], &efi_tcg2_guid,
(void **)&proto);
if (ret != EFI_SUCCESS) {
log_warning("- TPM %d failed (ret=0x%x)\n", i, ret);
continue;
}
plat = malloc(sizeof(*plat));
if (!plat) {
log_warning("- TPM %d failed to alloc platform data", i);
continue;
}
plat->handle = handle[i];
plat->proto = proto;
ret = device_bind(dm_root(), DM_DRIVER_GET(efi_net), "efi_tpm",
plat, ofnode_null(), &dev);
if (ret) {
log_warning("- bind TPM %d failed (ret=0x%x)\n", i,
ret);
continue;
}
snprintf(name, sizeof(name), "efi_tpm_%x", dev_seq(dev));
device_set_name(dev, name);
printf("%2d: %-12s\n", i, dev->name);
}
boot->free_pool(handle);
return 0;
}
/**
* board_early_init_r() - Scan for UEFI devices that should be available
*
* This sets up block devices within U-Boot for those found in UEFI. With this,
* U-Boot can access those devices
*
* Returns: 0 on success, -ve on error
*/
int board_early_init_r(void)
{
if (gd->flags & GD_FLG_RELOC) {
int ret;
ret = setup_block();
if (ret)
return ret;
ret = setup_net();
if (ret)
return ret;
ret = setup_tpm();
if (ret)
return ret;
}
return 0;
}

6
lib/efi/efi_dtb.S
View File

@@ -1,6 +0,0 @@
/* SPDX-License-Identifier: GPL-2.0+ */
#ifdef CONFIG_OF_SEPARATE
.section .embedded_dtb, "a"
.globl __dtb
__dtb: .fill 1024*1024
#endif

209
lib/efi/efi_info.c
View File

@@ -1,209 +0,0 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2015 Google, Inc
*
* Access to the EFI information table
*/
#include <efi.h>
#include <efi_loader.h>
#include <efi_stub.h>
#include <errno.h>
#include <mapmem.h>
#include <asm/global_data.h>
#include <efi_api.h>
#include <dm/of.h>
#include <dm/ofnode.h>
#include <dm/of_access.h>
#include <log.h>
DECLARE_GLOBAL_DATA_PTR;
int efi_info_get(enum efi_entry_t type, void **datap, int *sizep)
{
struct efi_entry_hdr *entry;
struct efi_info_hdr *info;
int ret;
if (!gd->arch.table)
return -ENODATA;
info = map_sysmem(gd->arch.table, 0);
if (info->version != EFI_TABLE_VERSION) {
ret = -EPROTONOSUPPORT;
goto err;
}
entry = (struct efi_entry_hdr *)((ulong)info + info->hdr_size);
while (entry->type != EFIET_END) {
if (entry->type == type) {
if (entry->addr)
*datap = map_sysmem(entry->addr, entry->size);
else
*datap = entry + 1;
*sizep = entry->size;
return 0;
}
entry = (struct efi_entry_hdr *)((ulong)entry + entry->link);
}
ret = -ENOENT;
err:
unmap_sysmem(info);
return -ENOSYS;
}
static int of_populate_framebuffer(struct device_node *root)
{
struct device_node *chosen, *fb;
struct efi_entry_gopmode *mode;
ofnode node;
int ret, size;
u64 reg[2];
char fb_node_name[50] = { 0 };
ret = efi_info_get(EFIET_GOP_MODE, (void **)&mode, &size);
if (ret) {
printf("EFI graphics output entry not found\n");
return ret;
}
fb = of_find_node_opts_by_path(root, "/chosen/framebuffer", NULL);
/* framebuffer already defined */
if (fb)
return 0;
chosen = of_find_node_opts_by_path(root, "/chosen", NULL);
if (!chosen) {
ret = of_add_subnode(root, "chosen", -1, &chosen);
if (ret) {
debug("Failed to add chosen node\n");
return ret;
}
}
node = np_to_ofnode(chosen);
ofnode_write_u32(node, "#address-cells", 2);
ofnode_write_u32(node, "#size-cells", 2);
/*
* In order for of_translate_one() to correctly detect an empty ranges property, the value
* pointer has to be non-null even though the length is 0.
*/
of_write_prop(chosen, "ranges", 0, (void *)FDT_ADDR_T_NONE);
snprintf(fb_node_name, sizeof(fb_node_name), "framebuffer@%llx", mode->fb_base);
ret = of_add_subnode(chosen, fb_node_name, -1, &fb);
if (ret) {
debug("Failed to add framebuffer node\n");
return ret;
}
node = np_to_ofnode(fb);
ofnode_write_string(node, "compatible", "simple-framebuffer");
reg[0] = cpu_to_fdt64(mode->fb_base);
reg[1] = cpu_to_fdt64(mode->fb_size);
ofnode_write_prop(node, "reg", reg, sizeof(reg), true);
ofnode_write_u32(node, "width", mode->info->width);
ofnode_write_u32(node, "height", mode->info->height);
ofnode_write_u32(node, "stride", mode->info->pixels_per_scanline * 4);
ofnode_write_string(node, "format", "a8r8g8b8");
return 0;
}
int of_populate_from_efi(struct device_node *root)
{
int ret = 0;
if (CONFIG_IS_ENABLED(VIDEO_SIMPLE) && CONFIG_IS_ENABLED(OF_LIVE))
ret = of_populate_framebuffer(root);
return ret;
}
static bool efi_mem_type_is_usable(u32 type)
{
switch (type) {
case EFI_CONVENTIONAL_MEMORY:
case EFI_LOADER_DATA:
case EFI_LOADER_CODE:
case EFI_BOOT_SERVICES_CODE:
return true;
case EFI_RESERVED_MEMORY_TYPE:
case EFI_UNUSABLE_MEMORY:
case EFI_UNACCEPTED_MEMORY_TYPE:
case EFI_RUNTIME_SERVICES_DATA:
case EFI_MMAP_IO:
case EFI_MMAP_IO_PORT:
case EFI_PERSISTENT_MEMORY_TYPE:
default:
return false;
}
}
int dram_init_banksize_from_efi(void)
{
struct efi_mem_desc *desc, *end;
struct efi_entry_memmap *map;
int ret, size, bank = 0;
int num_banks;
ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
if (ret) {
/* We should have stopped in dram_init(), something is wrong */
debug("%s: Missing memory map\n", __func__);
return -ENXIO;
}
end = (struct efi_mem_desc *)((ulong)map + size);
desc = map->desc;
for (num_banks = 0;
desc < end && num_banks < CONFIG_NR_DRAM_BANKS;
desc = efi_get_next_mem_desc(desc, map->desc_size)) {
/*
* We only use conventional memory and ignore
* anything less than 1MB.
*/
log_debug("EFI bank #%d: start %llx, size %llx type %u\n",
bank, desc->physical_start,
desc->num_pages << EFI_PAGE_SHIFT, desc->type);
bank++;
if (!efi_mem_type_is_usable(desc->type) ||
(desc->num_pages << EFI_PAGE_SHIFT) < 1 << 20)
continue;
gd->bd->bi_dram[num_banks].start = desc->physical_start;
gd->bd->bi_dram[num_banks].size = desc->num_pages <<
EFI_PAGE_SHIFT;
num_banks++;
}
return 0;
}
/* Called by U-Boot's EFI subsystem to add known memory. In our case
* we need to add some specific memory types from the original bootloaders
* EFI memory map
*/
void efi_add_known_memory_from_efi(void)
{
struct efi_mem_desc *desc, *end;
struct efi_entry_memmap *map;
int ret, size;
EFI_PRINT("Adding known memory from previous stage EFI bootloader\n");
ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
if (ret) {
EFI_PRINT("%s: Missing memory map\n", __func__);
return;
}
end = (struct efi_mem_desc *)((ulong)map + size);
for (desc = map->desc; desc < end; desc = efi_get_next_mem_desc(desc, map->desc_size)) {
switch (desc->type) {
case EFI_RESERVED_MEMORY_TYPE:
efi_add_memory_map_pg(desc->physical_start, desc->num_pages, desc->type, false);
break;
default:
continue;
}
}
}

237
lib/efi/efi_stub_arm64.c
View File

@@ -1,237 +0,0 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2015 Google, Inc
* Copyright (c) 2024 Linaro, Ltd.
*
* EFI information obtained here:
* http://wiki.phoenix.com/wiki/index.php/EFI_BOOT_SERVICES
*
* Call ExitBootServices() and launch U-Boot from an EFI environment.
*/
#include <debug_uart.h>
#include <efi.h>
#include <efi_api.h>
#include <efi_stub.h>
#include <malloc.h>
#include <asm/io.h>
#include <linux/err.h>
#include <linux/types.h>
static bool ebs_called;
void _debug_uart_putc(int ch)
{
struct efi_priv *priv = efi_get_priv();
if (ch == '\n')
_debug_uart_putc('\r');
/*
* After calling EBS we can't log anywhere.
* NOTE: for development it is possible to re-implement
* your boards debug uart here like in efi_stub.c for x86.
*/
if (!ebs_called)
efi_putc(priv, ch);
}
void _debug_uart_init(void) {}
DEBUG_UART_FUNCS;
void putc(const char ch)
{
_debug_uart_putc(ch);
}
void puts(const char *str)
{
while (*str)
putc(*str++);
}
void *memcpy(void *dest, const void *src, size_t size)
{
unsigned char *dptr = dest;
const unsigned char *ptr = src;
const unsigned char *end = src + size;
while (ptr < end)
*dptr++ = *ptr++;
return dest;
}
void *memset(void *inptr, int ch, size_t size)
{
char *ptr = inptr;
char *end = ptr + size;
while (ptr < end)
*ptr++ = ch;
return ptr;
}
/**
* setup_info_table() - sets up a table containing information from EFI
*
* We must call exit_boot_services() before jumping out of the stub into U-Boot
* proper, so that U-Boot has full control of peripherals, memory, etc.
*
* Once we do this, we cannot call any boot-services functions so we must find
* out everything we need to before doing that.
*
* Set up a struct efi_info_hdr table which can hold various records (e.g.
* struct efi_entry_memmap) with information obtained from EFI.
*
* @priv: Pointer to our private information which contains the list
* @size: Size of the table to allocate
* Return: 0 if OK, non-zero on error
*/
static int setup_info_table(struct efi_priv *priv, int size)
{
struct efi_info_hdr *info;
efi_status_t ret;
/* Get some memory for our info table */
priv->info_size = size;
info = efi_malloc(priv, priv->info_size, &ret);
if (ret) {
printhex2(ret);
puts(" No memory for info table: ");
return ret;
}
memset(info, '\0', sizeof(*info));
info->version = EFI_TABLE_VERSION;
info->hdr_size = sizeof(*info);
priv->info = info;
priv->next_hdr = (char *)info + info->hdr_size;
return 0;
}
/**
* add_entry_addr() - Add a new entry to the efi_info list
*
* This adds an entry, consisting of a tag and two lots of data. This avoids the
* caller having to coalesce the data first
*
* @priv: Pointer to our private information which contains the list
* @type: Type of the entry to add
* @ptr1: Pointer to first data block to add
* @size1: Size of first data block in bytes (can be 0)
* @ptr2: Pointer to second data block to add
* @size2: Size of second data block in bytes (can be 0)
*/
static void add_entry_addr(struct efi_priv *priv, enum efi_entry_t type,
void *ptr1, int size1, void *ptr2, int size2)
{
struct efi_entry_hdr *hdr = priv->next_hdr;
hdr->type = type;
hdr->size = size1 + size2;
hdr->addr = 0;
hdr->link = ALIGN(sizeof(*hdr) + hdr->size, 16);
priv->next_hdr += hdr->link;
memcpy(hdr + 1, ptr1, size1);
memcpy((void *)(hdr + 1) + size1, ptr2, size2);
priv->info->total_size = (ulong)priv->next_hdr - (ulong)priv->info;
}
/**
* efi_main() - Start an EFI image
*
* This function is called by our EFI start-up code. It handles running
* U-Boot. If it returns, EFI will continue.
*/
efi_status_t EFIAPI efi_main(efi_handle_t image,
struct efi_system_table *sys_table)
{
struct efi_priv local_priv, *priv = &local_priv;
struct efi_boot_services *boot = sys_table->boottime;
struct efi_entry_memmap map;
struct efi_gop *gop;
struct efi_entry_gopmode mode;
struct efi_entry_systable table;
efi_guid_t efi_gop_guid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
efi_status_t ret;
ebs_called = false;
ret = efi_init(priv, "Payload", image, sys_table);
if (ret) {
printhex2(ret);
puts(" efi_init() failed\n");
return ret;
}
efi_set_priv(priv);
phys_addr_t reloc_addr = ULONG_MAX;
ret = boot->allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, EFI_LOADER_CODE,
(phys_addr_t)_binary_u_boot_bin_size / EFI_PAGE_SIZE,
&reloc_addr);
if (ret != EFI_SUCCESS) {
puts("Failed to allocate memory for U-Boot: ");
printhex2(ret);
putc('\n');
return ret;
}
ret = efi_store_memory_map(priv);
if (ret)
return ret;
ret = setup_info_table(priv, priv->memmap_size + 128);
if (ret)
return ret;
ret = boot->locate_protocol(&efi_gop_guid, NULL, (void **)&gop);
if (ret) {
puts(" GOP unavailable\n");
} else {
mode.fb_base = gop->mode->fb_base;
mode.fb_size = gop->mode->fb_size;
mode.info_size = gop->mode->info_size;
add_entry_addr(priv, EFIET_GOP_MODE, &mode, sizeof(mode),
gop->mode->info,
sizeof(struct efi_gop_mode_info));
}
table.sys_table = (ulong)sys_table;
add_entry_addr(priv, EFIET_SYS_TABLE, &table, sizeof(table), NULL, 0);
ret = efi_call_exit_boot_services();
if (ret)
return ret;
/* The EFI console won't work now :( */
ebs_called = true;
map.version = priv->memmap_version;
map.desc_size = priv->memmap_desc_size;
add_entry_addr(priv, EFIET_MEMORY_MAP, &map, sizeof(map),
priv->memmap_desc, priv->memmap_size);
add_entry_addr(priv, EFIET_END, NULL, 0, 0, 0);
memcpy((void *)reloc_addr, _binary_u_boot_bin_start,
(ulong)_binary_u_boot_bin_end -
(ulong)_binary_u_boot_bin_start);
/* This will only work if you patched your own debug uart into this file. */
#ifdef DEBUG
puts("EFI table at ");
printhex8((ulong)priv->info);
puts(" size ");
printhex8(priv->info->total_size);
putc('\n');
#endif
typedef void (*func_t)(u64 x0, u64 x1, u64 x2, u64 x3);
puts("Jumping to U-Boot\n");
((func_t)reloc_addr)((phys_addr_t)priv->info, 0, 0, 0);
return EFI_LOAD_ERROR;
}

377
lib/efi/efi_stub_x86.c
View File

@@ -1,377 +0,0 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2015 Google, Inc
*
* EFI information obtained here:
* http://wiki.phoenix.com/wiki/index.php/EFI_BOOT_SERVICES
*
* Loads a payload (U-Boot) within the EFI environment. This is built as an
* EFI application. It can be built either in 32-bit or 64-bit mode.
*/
#include <debug_uart.h>
#include <efi.h>
#include <efi_api.h>
#include <efi_stub.h>
#include <errno.h>
#include <malloc.h>
#include <ns16550.h>
#include <asm/cpu.h>
#include <asm/io.h>
#include <linux/err.h>
#include <linux/types.h>
#ifndef CONFIG_X86
/*
* Problem areas:
* - putc() uses the ns16550 address directly and assumed I/O access. Many
* platforms will use memory access
* get_codeseg32() is only meaningful on x86
*/
#error "This file needs to be ported for use on architectures"
#endif
static bool use_uart;
struct __packed desctab_info {
uint16_t limit;
uint64_t addr;
uint16_t pad;
};
/*
* EFI uses Unicode and we don't. The easiest way to get a sensible output
* function is to use the U-Boot debug UART. We use EFI's console output
* function where available, and assume the built-in UART after that. We rely
* on EFI to set up the UART for us and just bring in the functions here.
* This last bit is a bit icky, but it's only for debugging anyway. We could
* build in ns16550.c with some effort, but this is a payload loader after
* all.
*
* Note: We avoid using printf() so we don't need to bring in lib/vsprintf.c.
* That would require some refactoring since we already build this for U-Boot.
* Building an EFI shared library version would have to be a separate stem.
* That might push us to using the SPL framework to build this stub. However
* that would involve a round of EFI-specific changes in SPL. Worth
* considering if we start needing more U-Boot functionality. Note that we
* could then move get_codeseg32() to arch/x86/cpu/cpu.c.
*/
void _debug_uart_init(void)
{
}
void putc(const char ch)
{
struct efi_priv *priv = efi_get_priv();
if (ch == '\n')
putc('\r');
if (use_uart) {
struct ns16550 *com_port = (struct ns16550 *)0x3f8;
while ((inb((ulong)&com_port->lsr) & UART_LSR_THRE) == 0)
;
outb(ch, (ulong)&com_port->thr);
} else {
efi_putc(priv, ch);
}
}
void puts(const char *str)
{
while (*str)
putc(*str++);
}
static void _debug_uart_putc(int ch)
{
putc(ch);
}
DEBUG_UART_FUNCS
void *memcpy(void *dest, const void *src, size_t size)
{
unsigned char *dptr = dest;
const unsigned char *ptr = src;
const unsigned char *end = src + size;
while (ptr < end)
*dptr++ = *ptr++;
return dest;
}
void *memset(void *inptr, int ch, size_t size)
{
char *ptr = inptr;
char *end = ptr + size;
while (ptr < end)
*ptr++ = ch;
return ptr;
}
static void jump_to_uboot(ulong cs32, ulong addr, ulong info)
{
#ifdef CONFIG_EFI_STUB_32BIT
/*
* U-Boot requires these parameters in registers, not on the stack.
* See _x86boot_start() for this code.
*/
typedef void (*func_t)(int bist, int unused, ulong info)
__attribute__((regparm(3)));
((func_t)addr)(0, 0, info);
#else
cpu_call32(cs32, CONFIG_TEXT_BASE, info);
#endif
}
#ifdef CONFIG_EFI_STUB_64BIT
static void get_gdt(struct desctab_info *info)
{
asm volatile ("sgdt %0" : : "m"(*info) : "memory");
}
#endif
static inline unsigned long read_cr3(void)
{
unsigned long val;
asm volatile("mov %%cr3,%0" : "=r" (val) : : "memory");
return val;
}
/**
* get_codeseg32() - Find the code segment to use for 32-bit code
*
* U-Boot only works in 32-bit mode at present, so when booting from 64-bit
* EFI we must first change to 32-bit mode. To do this we need to find the
* correct code segment to use (an entry in the Global Descriptor Table).
*
* Return: code segment GDT offset, or 0 for 32-bit EFI, -ENOENT if not found
*/
static int get_codeseg32(void)
{
int cs32 = 0;
#ifdef CONFIG_EFI_STUB_64BIT
struct desctab_info gdt;
uint64_t *ptr;
int i;
get_gdt(&gdt);
for (ptr = (uint64_t *)(unsigned long)gdt.addr, i = 0; i < gdt.limit;
i += 8, ptr++) {
uint64_t desc = *ptr;
uint64_t base, limit;
/*
* Check that the target U-Boot jump address is within the
* selector and that the selector is of the right type.
*/
base = ((desc >> GDT_BASE_LOW_SHIFT) & GDT_BASE_LOW_MASK) |
((desc >> GDT_BASE_HIGH_SHIFT) & GDT_BASE_HIGH_MASK)
<< 16;
limit = ((desc >> GDT_LIMIT_LOW_SHIFT) & GDT_LIMIT_LOW_MASK) |
((desc >> GDT_LIMIT_HIGH_SHIFT) & GDT_LIMIT_HIGH_MASK)
<< 16;
base <<= 12; /* 4KB granularity */
limit <<= 12;
if ((desc & GDT_PRESENT) && (desc & GDT_NOTSYS) &&
!(desc & GDT_LONG) && (desc & GDT_4KB) &&
(desc & GDT_32BIT) && (desc & GDT_CODE) &&
CONFIG_TEXT_BASE > base &&
CONFIG_TEXT_BASE + CONFIG_SYS_MONITOR_LEN < limit
) {
cs32 = i;
break;
}
}
#ifdef DEBUG
puts("\ngdt: ");
printhex8(gdt.limit);
puts(", addr: ");
printhex8(gdt.addr >> 32);
printhex8(gdt.addr);
for (i = 0; i < gdt.limit; i += 8) {
uint32_t *ptr = (uint32_t *)((unsigned long)gdt.addr + i);
puts("\n");
printhex2(i);
puts(": ");
printhex8(ptr[1]);
puts(" ");
printhex8(ptr[0]);
}
puts("\n ");
puts("32-bit code segment: ");
printhex2(cs32);
puts("\n ");
puts("page_table: ");
printhex8(read_cr3());
puts("\n ");
#endif
if (!cs32) {
puts("Can't find 32-bit code segment\n");
return -ENOENT;
}
#endif
return cs32;
}
/**
* setup_info_table() - sets up a table containing information from EFI
*
* We must call exit_boot_services() before jumping out of the stub into U-Boot
* proper, so that U-Boot has full control of peripherals, memory, etc.
*
* Once we do this, we cannot call any boot-services functions so we must find
* out everything we need to before doing that.
*
* Set up a struct efi_info_hdr table which can hold various records (e.g.
* struct efi_entry_memmap) with information obtained from EFI.
*
* @priv: Pointer to our private information which contains the list
* @size: Size of the table to allocate
* Return: 0 if OK, non-zero on error
*/
static int setup_info_table(struct efi_priv *priv, int size)
{
struct efi_info_hdr *info;
efi_status_t ret;
/* Get some memory for our info table */
priv->info_size = size;
info = efi_malloc(priv, priv->info_size, &ret);
if (ret) {
printhex2(ret);
puts(" No memory for info table: ");
return ret;
}
memset(info, '\0', sizeof(*info));
info->version = EFI_TABLE_VERSION;
info->hdr_size = sizeof(*info);
priv->info = info;
priv->next_hdr = (char *)info + info->hdr_size;
return 0;
}
/**
* add_entry_addr() - Add a new entry to the efi_info list
*
* This adds an entry, consisting of a tag and two lots of data. This avoids the
* caller having to coalesce the data first
*
* @priv: Pointer to our private information which contains the list
* @type: Type of the entry to add
* @ptr1: Pointer to first data block to add
* @size1: Size of first data block in bytes (can be 0)
* @ptr2: Pointer to second data block to add
* @size2: Size of second data block in bytes (can be 0)
*/
static void add_entry_addr(struct efi_priv *priv, enum efi_entry_t type,
void *ptr1, int size1, void *ptr2, int size2)
{
struct efi_entry_hdr *hdr = priv->next_hdr;
hdr->type = type;
hdr->size = size1 + size2;
hdr->addr = 0;
hdr->link = ALIGN(sizeof(*hdr) + hdr->size, 16);
priv->next_hdr += hdr->link;
memcpy(hdr + 1, ptr1, size1);
memcpy((void *)(hdr + 1) + size1, ptr2, size2);
priv->info->total_size = (ulong)priv->next_hdr - (ulong)priv->info;
}
/**
* efi_main() - Start an EFI image
*
* This function is called by our EFI start-up code. It handles running
* U-Boot. If it returns, EFI will continue.
*/
efi_status_t EFIAPI efi_main(efi_handle_t image,
struct efi_system_table *sys_table)
{
struct efi_priv local_priv, *priv = &local_priv;
struct efi_boot_services *boot = sys_table->boottime;
struct efi_entry_memmap map;
struct efi_gop *gop;
struct efi_entry_gopmode mode;
struct efi_entry_systable table;
efi_guid_t efi_gop_guid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
efi_status_t ret;
int cs32;
ret = efi_init(priv, "Payload", image, sys_table);
if (ret) {
printhex2(ret);
puts(" efi_init() failed\n");
return ret;
}
efi_set_priv(priv);
cs32 = get_codeseg32();
if (cs32 < 0)
return EFI_UNSUPPORTED;
ret = efi_store_memory_map(priv);
if (ret)
return ret;
ret = setup_info_table(priv, priv->memmap_size + 128);
if (ret)
return ret;
ret = boot->locate_protocol(&efi_gop_guid, NULL, (void **)&gop);
if (ret) {
puts(" GOP unavailable\n");
} else {
mode.fb_base = gop->mode->fb_base;
mode.fb_size = gop->mode->fb_size;
mode.info_size = gop->mode->info_size;
add_entry_addr(priv, EFIET_GOP_MODE, &mode, sizeof(mode),
gop->mode->info,
sizeof(struct efi_gop_mode_info));
}
table.sys_table = (ulong)sys_table;
add_entry_addr(priv, EFIET_SYS_TABLE, &table, sizeof(table), NULL, 0);
ret = efi_call_exit_boot_services();
if (ret)
return ret;
/* The EFI UART won't work now, switch to a debug one */
use_uart = true;
map.version = priv->memmap_version;
map.desc_size = priv->memmap_desc_size;
add_entry_addr(priv, EFIET_MEMORY_MAP, &map, sizeof(map),
priv->memmap_desc, priv->memmap_size);
add_entry_addr(priv, EFIET_END, NULL, 0, 0, 0);
memcpy((void *)CONFIG_TEXT_BASE, _binary_u_boot_bin_start,
(ulong)_binary_u_boot_bin_end -
(ulong)_binary_u_boot_bin_start);
#ifdef DEBUG
puts("EFI table at ");
printhex8((ulong)priv->info);
puts(" size ");
printhex8(priv->info->total_size);
#endif
putc('\n');
jump_to_uboot(cs32, CONFIG_TEXT_BASE, (ulong)priv->info);
return EFI_LOAD_ERROR;
}

44
lib/efi/efi_vars.c
View File

@@ -1,44 +0,0 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Aurora Innovation, Inc. Copyright 2022.
*
*/
#define __efi_runtime
#include <errno.h>
#include <asm/global_data.h>
#include <efi.h>
#include <efi_api.h>
#include <efi_variable.h>
DECLARE_GLOBAL_DATA_PTR;
efi_status_t efi_get_variable_int(const u16 *variable_name, const efi_guid_t *vendor,
u32 *attributes, efi_uintn_t *data_size,
void *data, u64 *timep)
{
struct efi_priv *priv = efi_get_priv();
struct efi_runtime_services *run = priv->run;
return run->get_variable((u16 *)variable_name, vendor, attributes, data_size, data);
}
efi_status_t efi_set_variable_int(const u16 *variable_name, const efi_guid_t *vendor,
u32 attributes, efi_uintn_t data_size, const void *data,
bool ro_check)
{
struct efi_priv *priv = efi_get_priv();
struct efi_runtime_services *run = priv->run;
return run->set_variable((u16 *)variable_name, vendor, attributes, data_size, data);
}
efi_status_t efi_get_next_variable_name_int(efi_uintn_t *variable_name_size,
u16 *variable_name, efi_guid_t *vendor)
{
struct efi_priv *priv = efi_get_priv();
struct efi_runtime_services *run = priv->run;
return run->get_next_variable_name(variable_name_size, variable_name, vendor);
}

30
lib/efi/sdram.c
View File

@@ -1,30 +0,0 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2015 Google, Inc
*/
#include <efi.h>
#include <init.h>
#include <asm/global_data.h>
DECLARE_GLOBAL_DATA_PTR;
phys_addr_t board_get_usable_ram_top(phys_size_t total_size)
{
return (ulong)efi_get_ram_base() + gd->ram_size;
}
int dram_init(void)
{
/* gd->ram_size is set as part of EFI init */
return 0;
}
int dram_init_banksize(void)
{
gd->bd->bi_dram[0].start = efi_get_ram_base();
gd->bd->bi_dram[0].size = CONFIG_EFI_RAM_SIZE;
return 0;
}