diff options
Diffstat (limited to 'lib/efi')
| -rw-r--r-- | lib/efi/Kconfig | 83 | ||||
| -rw-r--r-- | lib/efi/Makefile | 17 | ||||
| -rw-r--r-- | lib/efi/efi.c | 208 | ||||
| -rw-r--r-- | lib/efi/efi_app.c | 235 | ||||
| -rw-r--r-- | lib/efi/efi_app_init.c | 205 | ||||
| -rw-r--r-- | lib/efi/efi_info.c | 46 | ||||
| -rw-r--r-- | lib/efi/efi_stub.c | 376 |
7 files changed, 8 insertions, 1162 deletions
diff --git a/lib/efi/Kconfig b/lib/efi/Kconfig index 81ed3e66b34..fc6d5b6d6c2 100644 --- a/lib/efi/Kconfig +++ b/lib/efi/Kconfig @@ -1,79 +1,12 @@ -menu "U-Boot as UEFI application" - depends on X86 +# SPDX-License-Identifier: GPL-2.0-or-later +# +# Copyright 2025 Simon Glass <sjg@chromium.org> +# config EFI - bool "Support running U-Boot from EFI" - depends on X86 - imply X86_TSC_READ_BASE + bool 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. + Indicates that EFI functionality is enabled, either via EFI_CLIENT or + EFI_LOADER -choice - prompt "Select EFI mode to use" - depends on X86 && EFI - -config EFI_APP - bool "Support running as an EFI application" - 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 - 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 - 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 + This is used to provide libraries shared by both. diff --git a/lib/efi/Makefile b/lib/efi/Makefile deleted file mode 100644 index 232fa684360..00000000000 --- a/lib/efi/Makefile +++ /dev/null @@ -1,17 +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 -obj-$(CONFIG_EFI_STUB) += efi_info.o - -CFLAGS_REMOVE_efi_stub.o := -mregparm=3 \ - $(if $(CONFIG_EFI_STUB_64BIT),-march=i386 -m32) -CFLAGS_efi_stub.o := -fpic -fshort-wchar \ - $(if $(CONFIG_EFI_STUB_64BIT),-m64) -CFLAGS_REMOVE_efi.o := -mregparm=3 \ - $(if $(CONFIG_EFI_STUB_64BIT),-march=i386 -m32) -CFLAGS_efi.o := -fpic -fshort-wchar \ - $(if $(CONFIG_EFI_STUB_64BIT),-m64) - -extra-$(CONFIG_EFI_STUB) += efi_stub.o efi.o diff --git a/lib/efi/efi.c b/lib/efi/efi.c deleted file mode 100644 index bcb34d67465..00000000000 --- a/lib/efi/efi.c +++ /dev/null @@ -1,208 +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->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; -} diff --git a/lib/efi/efi_app.c b/lib/efi/efi_app.c deleted file mode 100644 index 9b94a93ee4f..00000000000 --- a/lib/efi/efi_app.c +++ /dev/null @@ -1,235 +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 <errno.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_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; - 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. - */ - global_data_ptr = efi_malloc(priv, sizeof(struct global_data), &ret); - if (!global_data_ptr) - return ret; - memset(gd, '\0', sizeof(*gd)); - - 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, gd); - global_data_ptr = 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; -} - -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, -}; diff --git a/lib/efi/efi_app_init.c b/lib/efi/efi_app_init.c deleted file mode 100644 index c5e4192fe06..00000000000 --- a/lib/efi/efi_app_init.c +++ /dev/null @@ -1,205 +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 <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; - -/** - * 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; - - plat.handle = handle; - plat.blkio = blkio; - plat.device_path = malloc(device_path->length); - if (!plat.device_path) - return log_msg_ret("path", -ENOMEM); - memcpy(plat.device_path, device_path, device_path->length); - 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; -} - -/** - * 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; - } - - return 0; -} diff --git a/lib/efi/efi_info.c b/lib/efi/efi_info.c deleted file mode 100644 index 5b564c5651d..00000000000 --- a/lib/efi/efi_info.c +++ /dev/null @@ -1,46 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0+ -/* - * Copyright (c) 2015 Google, Inc - * - * Access to the EFI information table - */ - -#include <efi.h> -#include <errno.h> -#include <mapmem.h> -#include <asm/global_data.h> - -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 ret; -} diff --git a/lib/efi/efi_stub.c b/lib/efi/efi_stub.c deleted file mode 100644 index a083c7f1e9b..00000000000 --- a/lib/efi/efi_stub.c +++ /dev/null @@ -1,376 +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 <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 inline 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; -} |